@nascentdigital/funnel-apps 4.4.18

package/dist/react/profile/domain/ProfileStore.d.ts

@@ -0,0 +1,65 @@
+import { EventBus } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { JsonValue, StringKeyOf } from 'type-fest';
+import { Identity } from '../../identity/domain';
+export declare abstract class ProfileStore<TData extends ProfileStore.Data = ProfileStore.Data> {
+    protected readonly _eventBus: EventBus;
+    protected readonly identity: Identity;
+    protected _data: TData;
+    protected readonly _edits: Map<ProfileStore.Data.Key<TData>, TData[keyof TData]>;
+    protected readonly _deletes: Set<ProfileStore.Data.Key<TData>>;
+    protected constructor(args: ProfileStore.ConstructorArgs<TData>);
+    get events$(): Observable<ProfileStore.Event>;
+    get modified(): boolean;
+    get id(): string;
+    get profileId(): string;
+    get data(): Partial<Omit<TData, ProfileStore.Data.ExcludedProps>>;
+    get<K extends ProfileStore.Data.Key<TData>>(key: K): TData[K] | undefined;
+    set<K extends ProfileStore.Data.Key<TData>>(key: K, value: TData[K]): this;
+    delete<K extends ProfileStore.Data.Key<TData>>(key: K): this;
+    clear(): this;
+    importChanges({ id, profileId, updates, deletes }: ProfileStore.Data.Changes<TData>): void;
+    exportChanges(): ProfileStore.Data.Changes<TData>;
+    reset(data?: TData): void;
+    abstract save(): Promise<void>;
+    toData(): TData;
+    toJSON(): any;
+    toString(): string;
+    protected raiseEvent(type: ProfileStore.Event.Type): void;
+}
+export declare namespace ProfileStore {
+    type Data<TId extends string = string, TCustomData extends Data.CustomData = Data.CustomData> = Partial<TCustomData> & {
+        __internals?: JsonValue;
+        id: TId;
+        profileId: string;
+    };
+    namespace Data {
+        type CustomData = Omit<Record<string, JsonValue>, ExcludedProps>;
+        type Key<TData extends Data> = StringKeyOf<Omit<TData, ExcludedProps>>;
+        type ExcludedProps = '__internals' | 'id' | 'profileId';
+        type Changes<TData extends Data = Data> = {
+            id: string;
+            profileId: string;
+            updates: Partial<Omit<TData, ExcludedProps>>;
+            deletes: Key<TData>[];
+        };
+        type Spec<TId extends string = string, TData extends CustomData = CustomData> = {
+            id: TId;
+        } & TData;
+        type For<TSpec extends Spec> = Data<Spec['id'], Omit<TSpec, 'id'>>;
+    }
+    type For<TSpec extends Data.Spec> = ProfileStore<Data.For<TSpec>>;
+    type ConstructorArgs<TData extends Data> = {
+        eventBus: EventBus;
+        identity: Identity;
+        data: TData;
+    };
+    interface Event extends EventBus.Event<'ProfileStore', Event.Type> {
+        store: ProfileStore;
+    }
+    namespace Event {
+        type Type = 'modified' | 'saved' | 'reset';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}

package/dist/react/profile/domain/ProfileStore.js

@@ -0,0 +1,180 @@
+"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.ProfileStore = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const rxjs_1 = require("rxjs");
+// class
+class ProfileStore {
+    constructor(args) {
+        // initialize instance variables
+        this._eventBus = args.eventBus;
+        this.identity = args.identity;
+        this._data = args.data;
+        this._edits = new Map();
+        this._deletes = new Set();
+    }
+    get events$() {
+        return this._eventBus.events$.pipe((0, rxjs_1.filter)(e => ProfileStore.Event.filter(e)), (0, rxjs_1.filter)(e => e.store === this));
+    }
+    get modified() {
+        return this._edits.size > 0 || this._deletes.size > 0;
+    }
+    get id() {
+        return this._data.id;
+    }
+    get profileId() {
+        return this._data.profileId;
+    }
+    get data() {
+        const _a = this._data, { __internals, id, profileId } = _a, data = __rest(_a, ["__internals", "id", "profileId"]);
+        return data;
+    }
+    get(key) {
+        const { _edits, _deletes, _data } = this;
+        return _deletes.has(key)
+            ? undefined
+            : _edits.has(key)
+                ? _edits.get(key)
+                : _data[key];
+    }
+    set(key, value) {
+        // update
+        this._edits.set(key, value);
+        this._deletes.delete(key);
+        // raise event
+        this.raiseEvent('modified');
+        // chain
+        return this;
+    }
+    delete(key) {
+        // or delete it
+        this._edits.delete(key);
+        this._deletes.add(key);
+        // raise event
+        this.raiseEvent('modified');
+        // chain
+        return this;
+    }
+    clear() {
+        // clear current edits and deletes
+        this._edits.clear();
+        this._deletes.clear();
+        // loop over data and remove each custom key
+        for (const key in this._data) {
+            // skip if preserved key
+            if (key === 'id' || key === 'profileId') {
+                continue;
+            }
+            // add to deletes and remove data
+            this._deletes.add(key);
+            delete this._data[key];
+        }
+        // raise event
+        this.raiseEvent('modified');
+        // chain
+        return this;
+    }
+    importChanges({ id, profileId, updates, deletes }) {
+        // ensure we aren't updating the wrong profile
+        const { _edits, _deletes, modified } = this;
+        if (this.id !== id || this.profileId !== profileId) {
+            throw new funnel_core_1.InvalidOperationError(`Cannot import cross-store changes (received ${profileId}/${id}, expected ${this.profileId}/${this.id})`);
+        }
+        // throw if there are already changes
+        if (modified) {
+            throw new funnel_core_1.InvalidOperationError('Cannot import to an already modified store');
+        }
+        // apply edits
+        Object.entries(updates).forEach(([key, value]) => _edits.set(key, value));
+        // apply deletes
+        deletes.forEach(key => _deletes.add(key));
+        // raise event
+        this.raiseEvent('modified');
+    }
+    exportChanges() {
+        // create base
+        const { id, profileId, _edits, _deletes } = this;
+        const changes = {
+            id,
+            profileId,
+            updates: {},
+            deletes: []
+        };
+        // apply updates
+        _edits.forEach((value, key) => {
+            changes.updates[key] = value;
+        });
+        // apply deletes
+        _deletes.forEach(key => {
+            changes.deletes.push(key);
+        });
+        // return changes
+        return changes;
+    }
+    reset(data) {
+        // reset fields
+        this._edits.clear();
+        this._deletes.clear();
+        // replace data (if required)
+        if (data) {
+            this._data = data;
+        }
+        // raise event
+        this.raiseEvent('reset');
+    }
+    toData() {
+        // just return data if modified
+        const { modified, _data, _edits, _deletes } = this;
+        if (!modified) {
+            return _data;
+        }
+        // serialize data with changes
+        const data = Object.assign({}, _data);
+        // override any edits
+        _edits.forEach((value, key) => {
+            data[key] = value;
+        });
+        // clear any deletes
+        _deletes.forEach((key) => {
+            delete data[key];
+        });
+        // return data
+        return data;
+    }
+    toJSON() {
+        return JSON.parse(JSON.stringify(this.toData()));
+    }
+    toString() {
+        return `${this.constructor.name}: ${this.profileId}/${this.id}`;
+    }
+    raiseEvent(type) {
+        this._eventBus.publish(ProfileStore.Event.create({ type, store: this }));
+    }
+}
+exports.ProfileStore = ProfileStore;
+// extension
+(function (ProfileStore) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'ProfileStore';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return funnel_core_1.EventBus.createEvent(Object.assign({ domain: 'ProfileStore' }, event));
+        }
+        Event.create = create;
+    })(Event = ProfileStore.Event || (ProfileStore.Event = {}));
+})(ProfileStore || (exports.ProfileStore = ProfileStore = {}));

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

@@ -0,0 +1,3 @@
+export * from './Profile';
+export * from './ProfileAppRequest';
+export * from './ProfileStore';

package/dist/react/profile/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("./Profile"), exports);
+__exportStar(require("./ProfileAppRequest"), exports);
+__exportStar(require("./ProfileStore"), exports);

package/dist/react/profile/server/ProfileAppService.d.ts

@@ -0,0 +1,11 @@
+import 'server-only';
+import { JsonValue } from 'type-fest';
+import { AbstractAppService } from '../../app/server/AbstractAppService';
+import { Identity } from '../../identity/domain';
+import { ProfileAppRequest } from '../domain';
+import { ProfileUserService } from './ProfileUserService';
+export declare class ProfileAppService extends AbstractAppService<ProfileAppRequest> {
+    private readonly _userService;
+    constructor(_userService: ProfileUserService);
+    onExecute(request: ProfileAppRequest, identity?: Identity): Promise<JsonValue>;
+}

package/dist/react/profile/server/ProfileAppService.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileAppService = void 0;
+require("server-only");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const AbstractAppService_1 = require("../../app/server/AbstractAppService");
+// service
+class ProfileAppService extends AbstractAppService_1.AbstractAppService {
+    constructor(_userService) {
+        // construct base
+        super({
+            id: '_nd-profile',
+            name: 'Profile Service'
+        });
+        this._userService = _userService;
+    }
+    async onExecute(request, identity) {
+        // throw if not authenticated
+        if (!identity) {
+            throw new funnel_core_1.NotAuthenticatedError();
+        }
+        // fetch profile
+        const profile = await this._userService.getProfile(identity);
+        // handle methods
+        switch (request.method) {
+            case 'profile.get': {
+                console.debug('[ProfileAppService] getting data', request);
+                return profile.toData();
+            }
+            case 'profile.update': {
+                console.debug('[ProfileAppService] setting data key value', request);
+                profile.importChanges(request.data);
+                await profile.save();
+                return profile.toData();
+            }
+            case 'store.update': {
+                console.debug('[ProfileAppService] delete data key value', request);
+                const changes = request.data;
+                const store = profile.getStore(changes.id);
+                store.importChanges(changes);
+                await store.save();
+                return store.toData();
+            }
+            default:
+                throw new funnel_core_1.InvalidOperationError(`Unrecognized ${this.name} method`);
+        }
+    }
+}
+exports.ProfileAppService = ProfileAppService;

package/dist/react/profile/server/ProfileManagementService.d.ts

@@ -0,0 +1,28 @@
+import 'server-only';
+import type { Pagination } from '@nascentdigital/funnel-cms';
+import type { Profile } from '../domain';
+export interface ProfileManagementService {
+    get(args: ProfileManagementService.Get.Args): Promise<ProfileManagementService.Get.Result>;
+    find(args?: ProfileManagementService.Find.Args): Promise<ProfileManagementService.Find.Result>;
+}
+export declare namespace ProfileManagementService {
+    type WithPagination = {
+        pagination: Pagination.Paging;
+    };
+    export namespace Get {
+        type Args = {
+            id?: string;
+            email?: string;
+        };
+        type Result = Profile | undefined;
+    }
+    export namespace Find {
+        type Args = Partial<WithPagination> & Partial<Profile.Data.Core>;
+        interface PaginatedIterator<T> extends Pagination.Paginated<T> {
+            nextPage(): Promise<void>;
+            hasNextPage: boolean;
+        }
+        type Result = PaginatedIterator<Profile>;
+    }
+    export {};
+}

package/dist/react/profile/server/ProfileManagementService.js

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

package/dist/react/profile/server/ProfileServices.d.ts

@@ -0,0 +1,22 @@
+import 'server-only';
+import { ProfileManagementService } from './ProfileManagementService';
+import { ProfileUserService } from './ProfileUserService';
+export interface ProfileServices {
+    /**
+     * Returns an authenticated {@link ProfileManagementService} for usage as a service account.
+     * This account should never be used for handling user requests, since it has full
+     * access and privileges.
+     *
+     * This instance is typically shared.
+     */
+    getManagementService(): ProfileManagementService;
+    /**
+     * Returns a new {@link ProfileUserService} that will be exposed as an {@link AppService} for proxying actions on
+     * behalf of a user.  This client should be stateless, since it will be used for handling multiple user requests.
+     */
+    getUserService(): ProfileUserService;
+}
+export declare namespace ProfileServices {
+    function get(): ProfileServices;
+    function set(factory: ProfileServices): void;
+}

package/dist/react/profile/server/ProfileServices.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileServices = void 0;
+require("server-only");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// extension
+var ProfileServices;
+(function (ProfileServices) {
+    // methods
+    function get() {
+        // throw if config isn't bound
+        if (!_factory) {
+            throw new funnel_core_1.IllegalStateError('Attempt to access ProfileServiceFactory before first call to ProfileServiceFactory.set()');
+        }
+        return _factory;
+    }
+    ProfileServices.get = get;
+    function set(factory) {
+        _factory = factory;
+    }
+    ProfileServices.set = set;
+})(ProfileServices || (exports.ProfileServices = ProfileServices = {}));
+// storage
+let _factory = undefined;

package/dist/react/profile/server/ProfileUserService.d.ts

@@ -0,0 +1,5 @@
+import { Identity } from '../../identity/domain';
+import { Profile } from '../domain';
+export interface ProfileUserService {
+    getProfile(identity: Identity): Promise<Profile>;
+}

package/dist/react/profile/server/ProfileUserService.js

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

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

@@ -0,0 +1,5 @@
+export * from '../domain';
+export * from './ProfileAppService';
+export * from './ProfileManagementService';
+export * from './ProfileServices';
+export * from './ProfileUserService';

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

@@ -0,0 +1,21 @@
+"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("../domain"), exports);
+__exportStar(require("./ProfileAppService"), exports);
+__exportStar(require("./ProfileManagementService"), exports);
+__exportStar(require("./ProfileServices"), exports);
+__exportStar(require("./ProfileUserService"), exports);

package/dist/react/profile/web/WebProfile.d.ts

@@ -0,0 +1,11 @@
+import { StringKeyOf } from 'type-fest';
+import { Profile } from '../domain';
+import { WebProfileStore } from './WebProfileStore';
+export declare class WebProfile<TStores extends Profile.Stores = Profile.Stores> extends Profile<TStores> {
+    constructor(args: WebProfile.ConstructorArgs<TStores>);
+    protected createStore(id: StringKeyOf<TStores>): WebProfileStore;
+    save(): Promise<void>;
+}
+export declare namespace WebProfile {
+    type ConstructorArgs<TStores extends Profile.Stores> = Profile.ConstructorArgs<TStores>;
+}

package/dist/react/profile/web/WebProfile.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebProfile = void 0;
+const web_1 = require("../../app/web");
+const domain_1 = require("../../identity/domain");
+const domain_2 = require("../domain");
+const WebProfileStore_1 = require("./WebProfileStore");
+// class
+class WebProfile extends domain_2.Profile {
+    constructor(args) {
+        // construct base
+        super(args);
+    }
+    createStore(id) {
+        const { _eventBus, identity, id: profileId } = this;
+        return new WebProfileStore_1.WebProfileStore({ eventBus: _eventBus, identity, data: { id, profileId } });
+    }
+    async save() {
+        // get props
+        const { identity } = this;
+        const changes = this.exportChanges();
+        // push update
+        const update = await web_1.AppServiceClient.post({
+            apiToken: identity instanceof domain_1.AuthenticatedIdentity
+                ? identity.apiToken
+                : undefined,
+            id: '_nd-profile',
+            method: 'profile.update',
+            data: JSON.parse(JSON.stringify(changes))
+        });
+        // reset to latest
+        this.reset(update);
+        // raise event
+        this.raiseEvent('saved');
+    }
+}
+exports.WebProfile = WebProfile;

package/dist/react/profile/web/WebProfileClient.d.ts

@@ -0,0 +1,9 @@
+import { AnonymousIdentity, AuthenticatedIdentity } from '../../identity/domain';
+import { AbstractProfileClient } from '../core';
+import type { Profile } from '../domain';
+import { WebProfile } from './WebProfile';
+export declare class WebProfileClient extends AbstractProfileClient {
+    constructor();
+    sync(identity: AuthenticatedIdentity | AnonymousIdentity): Promise<WebProfile | null>;
+    hydrate(identity: AuthenticatedIdentity | AnonymousIdentity, { __stores, ...data }: Profile.Data): Promise<WebProfile>;
+}

package/dist/react/profile/web/WebProfileClient.js

@@ -0,0 +1,76 @@
+"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.WebProfileClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const web_1 = require("../../app/web");
+const domain_1 = require("../../identity/domain");
+const core_1 = require("../core");
+const WebProfile_1 = require("./WebProfile");
+const WebProfileStore_1 = require("./WebProfileStore");
+// class
+class WebProfileClient extends core_1.AbstractProfileClient {
+    constructor() {
+        // construct base
+        super();
+    }
+    async sync(identity) {
+        // skip if anonymous
+        if (identity instanceof domain_1.AnonymousIdentity) {
+            this.profile = null;
+            return null;
+        }
+        // fetch profile data
+        try {
+            const data = await web_1.AppServiceClient.post({
+                apiToken: identity.apiToken,
+                id: '_nd-profile',
+                method: 'profile.get',
+                data: null
+            });
+            const spec = await web_1.AppServiceClient.post({
+                apiToken: identity.apiToken,
+                id: '_nd-nav',
+                method: 'getSpec',
+                data: null
+            });
+            console.debug('[WebProfileClient] fetched spec', spec);
+            // set initial profile instance
+            return this.hydrate(identity, data);
+        }
+        // logout if not authenticated
+        catch (e) {
+            console.error('[WebProfileClient] failed to get profile', e);
+            this.profile = null;
+            throw e;
+        }
+    }
+    async hydrate(identity, _a) {
+        var { __stores } = _a, data = __rest(_a, ["__stores"]);
+        // create profile
+        const eventBus = new funnel_core_1.EventBus();
+        const profile = new WebProfile_1.WebProfile(Object.assign(Object.assign({}, data), { eventBus,
+            identity, stores: (__stores !== null && __stores !== void 0 ? __stores : []).reduce((stores, data) => {
+                // transform store and bind it
+                const store = new WebProfileStore_1.WebProfileStore({ eventBus, identity, data });
+                stores[store.id] = store;
+                // keep reducing
+                return stores;
+            }, {}) }));
+        // bind it
+        this.profile = profile;
+        // and return it
+        return profile;
+    }
+}
+exports.WebProfileClient = WebProfileClient;

package/dist/react/profile/web/WebProfileProvider.d.ts

@@ -0,0 +1,5 @@
+import { PropsWithChildren } from 'react';
+export declare function WebProfileProvider({ children }: WebProfileProvider.Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace WebProfileProvider {
+    type Props = PropsWithChildren;
+}

package/dist/react/profile/web/WebProfileProvider.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebProfileProvider = WebProfileProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const react_1 = require("react");
+const web_1 = require("../../bridge/web");
+const core_1 = require("../../identity/core");
+const core_2 = require("../core");
+const WebProfileClient_1 = require("./WebProfileClient");
+// container
+function WebProfileProvider({ children }) {
+    // bind hooks + context
+    const profileClient = (0, react_1.useMemo)(() => new WebProfileClient_1.WebProfileClient(), []);
+    const context = (0, react_1.useMemo)(() => ({ profileClient }), [profileClient]);
+    const bridge = (0, web_1.useBridge)();
+    const { isNative, connected } = bridge;
+    const { profileData } = bridge.state;
+    const { identity } = (0, core_1.useIdentity)();
+    const identityClient = (0, core_1.useIdentityClient)();
+    const identityClientRef = (0, react_1.useRef)(identityClient);
+    identityClientRef.current = identityClient;
+    // sync context when identity changes
+    (0, react_1.useEffect)(() => {
+        // ignore if there's no identity
+        if (!identity) {
+            return;
+        }
+        // or ignore if waiting for native bridge to bind
+        else if (isNative && !connected) {
+            console.debug('[WebProfileProvider] waiting for native bridge to bind');
+            return;
+        }
+        // leverage bridge if there's existing profile data
+        if (isNative && profileData) {
+            console.debug('[WebProfileProvider] leveraging existing profile from bridge');
+            profileClient
+                .hydrate(identity, profileData)
+                .catch(e => console.error('[WebProfileProvider] failed to hydrate profile', e));
+        }
+        // or sync directly if not native
+        else {
+            console.debug('[WebProfileProvider] fetching fresh profile for identity', identity);
+            // sync profile
+            profileClient.sync(identity)
+                // propagate profile back to native (if required)
+                .then(profile => {
+                if (isNative) {
+                    bridge.setState('profileData', profile ? JSON.parse(JSON.stringify(profile.toData())) : null);
+                }
+            })
+                // or handle error
+                .catch(e => {
+                if (e instanceof funnel_core_1.NotAuthenticatedError) {
+                    identityClientRef.current.logout();
+                }
+            });
+        }
+    }, [bridge, profileClient, identity, isNative, connected, profileData]);
+    // render
+    return ((0, jsx_runtime_1.jsx)(core_2.ProfileClientContext.Provider, { value: context, children: children }));
+}