@nascentdigital/funnel-editor-contentful 5.0.1 → 5.0.3

package/dist/collection/repository/CollectionRepository.js

@@ -0,0 +1,223 @@
+"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.CollectionRepository = void 0;
+const contentful_1 = require("@nascentdigital/funnel-cms/contentful");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const domain_1 = require("../domain");
+// repository
+class CollectionRepository {
+    constructor(args) {
+        // initialize instance
+        this.sdk = args.sdk;
+        this.contentfulClient = args.contentfulClient;
+    }
+    async getOverview(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async getItems(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async get(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async create(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async createRaw(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async createLanguage(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async update(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    serializeUpdate(collection, savables) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async load(sys) {
+        // blow up if we're not in the editor
+        const { sdk, contentfulClient } = this;
+        if (!('entry' in sdk)) {
+            throw new funnel_core_1.InvalidOperationError('Attempt to call load() outside of EntryEditor');
+        }
+        // throw if entry isn't a collection (it should be in this case)
+        const { entry } = sdk;
+        sys = sys !== null && sys !== void 0 ? sys : entry.getSys();
+        const { id: entryId, contentType: { sys: { id: entryType } } } = sys;
+        if (entryType !== contentful_1.ContentfulCollectionData.contentType) {
+            throw new funnel_core_1.ArgumentError(`Cannot load Collection from entry that isn't of "${contentful_1.ContentfulCollectionData.contentType}" type`);
+        }
+        // throw if page doesn't have a group id
+        const collectionId = entryId;
+        const type = entry.fields.type.getValue();
+        const groupId = entry.fields.groupId.getValue();
+        const brand = entry.fields.brand.getValue();
+        const language = funnel_core_1.Language.tryParse(entry.fields.language.getValue());
+        if (!groupId || !type || !brand || !language) {
+            throw new funnel_core_1.ArgumentError(`Collection "${collectionId}" is not configured (missing required fields)`);
+        }
+        // fetch remote data (throw if not found)
+        const result = await contentfulClient.collections.getGroup({ groupId, type, brand, language, version: 'draft' });
+        if (!result) {
+            throw new funnel_core_1.NotFoundError(`Unable to resolve Collection with id "${collectionId}"`);
+        }
+        const _a = result.group, { instances: collections } = _a, group = __rest(_a, ["instances"]), { collection: collectionResult } = result;
+        if (!collectionResult) {
+            throw new funnel_core_1.NotFoundError(`Unable to resolve Collection with id "${collectionId}"`);
+        }
+        // get entry data + remote references
+        const { data: _remote } = collectionResult, references = __rest(collectionResult, ["data"]);
+        const data = entryToCollectionData(entry);
+        // return collection model from data
+        const collection = domain_1.Collection.fromSchemaData({ data, references });
+        return {
+            collectionGroup: new components_1.CollectionGroup(Object.assign({ template: collection.template, collections }, group)),
+            collection,
+            sys
+        };
+    }
+    async save(collection) {
+        // guard method
+        const { sdk } = this;
+        if (!('entry' in sdk)) {
+            throw new funnel_core_1.InvalidOperationError('Attempt to call save() outside of EntryEditor');
+        }
+        // serialize collection updates (or skip if there are no changes)
+        const savables = [];
+        const updateArgs = domain_1.Collection.toUpdates(collection, savables);
+        if (updateArgs.updates.length === 0) {
+            return collection;
+        }
+        // start all updates
+        collection.onSaveStart();
+        savables.forEach(savable => savable.onSaveStart());
+        // update entry if page is local
+        let updatedOn;
+        const { entry } = sdk;
+        const { id: entryId, contentType: { sys: { id: entryType } } } = entry.getSys();
+        if (entryType === contentful_1.ContentfulCollectionData.contentType && collection.id === entryId) {
+            console.debug('[CollectionRepository/save] saving local entry', { entry, collection, updates: updateArgs.updates });
+            // save updates to entry
+            await saveEntryUpdates({ entry, updates: updateArgs.updates });
+            // capture updated timestamp
+            updatedOn = new Date(entry.getSys().updatedAt).getTime();
+        }
+        // or update remotely
+        else {
+            console.debug('[CollectionRepository/save] saving remote entry', collection);
+            // push updates remotely
+            const result = await this.contentfulClient.collections.update(updateArgs);
+            // capture update timestamp
+            updatedOn = result.updatedOn;
+            // swap to new collection (if update returned new data)
+            if (result.collection) {
+                console.debug('[PageRepository/save] switching to new page data', result.collection);
+                const _a = result.collection, { data } = _a, references = __rest(_a, ["data"]);
+                collection = domain_1.Collection.fromSchemaData({ data, references });
+            }
+        }
+        console.debug('[PageRepository/save] finalizing save');
+        // complete updates
+        savables.forEach(savable => savable.onSaveComplete());
+        collection.onSaveComplete(updatedOn);
+        console.debug('[PageRepository/save] save complete', collection);
+        // return collection
+        return collection;
+    }
+    async sync({ collection, sys }) {
+        // guard method
+        const { sdk } = this;
+        if (!('entry' in sdk)) {
+            throw new funnel_core_1.InvalidOperationError('Attempt to call sync() outside of EntryEditor');
+        }
+        // skip if entity version and updated sys are same
+        const { entry } = sdk;
+        const entrySys = entry.getSys();
+        if (sys.version === entrySys.version) {
+            console.debug('[ContentfulCollectionRepository/sync] ignoring unchanged entity');
+            return { collection, sys };
+        }
+        // force reload if entry references changed
+        const entryReferences = entry.fields.references.getValue();
+        const entryRefs = new Set(entryReferences.map(link => `${link.sys.linkType}.${link.sys.id}`));
+        const { references: collectionReferences } = collection;
+        const collectionRefs = new Set(collectionReferences.map(link => `${link.sys.linkType}.${link.sys.id}`));
+        if (!collectionRefs.isSupersetOf(entryRefs)) {
+            console.debug('[ContentfulCollectionRepository/sync] references changed - triggering reload');
+            return this.load(sys);
+        }
+        console.debug('[ContentfulCollectionRepository/sync] reusing stable references - merging entity');
+        // or load page data, but use old references in store
+        const data = entryToCollectionData(entry);
+        const references = {
+            files: collection.assets.reduce((files, file) => {
+                files[file.value.id] = file;
+                return files;
+            }, {}),
+            collections: collection.collections.reduce((collections, collection) => {
+                collections[collection.id] = collection;
+                return collections;
+            }, {}),
+        };
+        // create new page (use existing sys)
+        return {
+            collection: domain_1.Collection.fromSchemaData({ data, references }),
+            sys
+        };
+    }
+    async unpublish(collection) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+}
+exports.CollectionRepository = CollectionRepository;
+// helpers
+function entryToCollectionData(entry) {
+    // throw if it's not a page
+    const entryType = entry.getSys().contentType.sys.id;
+    if (entryType !== contentful_1.ContentfulCollectionData.contentType) {
+        throw new funnel_core_1.ArgumentError(`Expected entry to be "${contentful_1.ContentfulCollectionData.contentType}", but found "${entryType}"`);
+    }
+    // serialize entry (this is the latest data)
+    const entryData = contentful_1.ContentfulData.fromEntryData(entry);
+    return contentful_1.ContentfulCollectionData.deserialize(entryData);
+}
+async function saveEntryUpdates({ entry, updates }) {
+    var _a;
+    // serialize entry (this is the latest data)
+    const entryData = contentful_1.ContentfulData.fromEntryData(entry);
+    const collectionData = contentful_1.ContentfulCollectionData.deserialize(entryData);
+    // create model and apply updates
+    const collectionModel = new funnel_core_1.Schema.CollectionModel(collectionData);
+    collectionModel.update(updates);
+    collectionModel.sync();
+    // resolve references
+    const references = contentful_1.ContentfulData.findReferences([collectionData.fields]);
+    // update fields
+    const { fields } = entry;
+    await Promise.all([
+        // required updates
+        fields.name.setValue(collectionData.name),
+        fields.state.setValue(collectionData.state),
+        fields.errors.setValue(collectionData.errors),
+        fields.references.setValue(references),
+        // TODO: save only fields that changed
+        // conditional updates
+        fields.tags.setValue((_a = collectionData.tags) !== null && _a !== void 0 ? _a : []),
+        fields.fields.setValue(collectionData.fields),
+    ]);
+    // save entry
+    await entry.save();
+}

package/dist/collection/repository/index.d.ts

@@ -0,0 +1 @@
+export * from './CollectionRepository';

package/dist/{core/contentful → collection/repository}/index.js

@@ -14,8 +14,4 @@ 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("./Contentful"), exports);
-__exportStar(require("./ContentfulAsset"), exports);
-__exportStar(require("./ContentfulCollection"), exports);
-__exportStar(require("./ContentfulPage"), exports);
-__exportStar(require("./ContentfulRefs"), exports);
+__exportStar(require("./CollectionRepository"), exports);

package/dist/collection/screens/CollectionEditor.js

@@ -2,24 +2,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionEditor = CollectionEditor;
 const jsx_runtime_1 = require("react/jsx-runtime");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
 const components_1 = require("@nascentdigital/funnel-editor/components");
 const react_1 = require("react");
 const controller_1 = require("../controller");
 // component
 function CollectionEditor() {
     // hooks
-    const controllerContext = (0, controller_1.useLocalCollectionController)();
-    const { controller } = controllerContext;
-    const { collection } = controller;
+    const splash = (0, components_1.useSplash)();
+    const controller = (0, controller_1.useContentfulCollectionController)();
+    const { ready, collection } = controller;
     const collectionContext = (0, react_1.useMemo)(() => ({ collection }), [collection]);
     // sync with controller
     (0, components_1.useCollectionController)(controller);
     // load
     (0, react_1.useEffect)(() => {
-        controller.load().catch(console.error);
-    }, [controller]);
+        controller.load().catch(e => {
+            // transform error
+            const error = funnel_core_1.IsometricErrorUtils.coerceError(e);
+            // TODO: come up with an appropriate message
+            const message = error.message;
+            // show error via splash
+            splash.showError({ message, onRetry: () => controller.reload() });
+        });
+    }, [controller, splash]);
+    // dismiss splash when ready
+    (0, react_1.useEffect)(() => {
+        if (ready) {
+            splash.dismiss();
+        }
+        else {
+            splash.showLoading('Fetching content');
+        }
+    }, [splash, ready]);
     // render
-    return ((0, jsx_runtime_1.jsx)(components_1.CollectionControllerContext.Provider, { value: controllerContext, children: (0, jsx_runtime_1.jsx)(components_1.CollectionContext.Provider, { value: collectionContext, children: (0, jsx_runtime_1.jsx)(components_1.AssetStoreContext.Provider, { value: collection, children: (0, jsx_runtime_1.jsx)(components_1.CollectionStoreContext.Provider, { value: collection, children: (0, jsx_runtime_1.jsx)("div", { className: "w-dvw h-dvh flex flex-col bg-background", children: (0, jsx_runtime_1.jsx)("div", { className: "relative flex-1", children: (0, jsx_runtime_1.jsx)("div", { className: "absolute inset-0 flex", children: (0, jsx_runtime_1.jsx)("section", { className: "flex-1 h-full max-h-full max-w-[1000px] mx-auto", children: renderContent({ controller }) }) }) }) }) }) }) }) }));
+    return ((0, jsx_runtime_1.jsx)(components_1.CollectionContext.Provider, { value: collectionContext, children: (0, jsx_runtime_1.jsx)(components_1.AssetStoreContext.Provider, { value: collection, children: (0, jsx_runtime_1.jsx)(components_1.CollectionStoreContext.Provider, { value: collection, children: (0, jsx_runtime_1.jsx)("div", { className: "w-dvw h-dvh flex flex-col bg-background", children: (0, jsx_runtime_1.jsx)("div", { className: "relative flex-1", children: (0, jsx_runtime_1.jsx)("div", { className: "absolute inset-0 flex", children: (0, jsx_runtime_1.jsx)("section", { className: "flex-1 h-full max-h-full max-w-[1000px] mx-auto", children: renderContent({ controller }) }) }) }) }) }) }) }));
 }
 function renderContent({ controller }) {
     // render loader if not ready

package/dist/core/bridge/AppBridge.d.ts

@@ -0,0 +1,31 @@
+import { Callback } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { Tagged } from 'type-fest';
+import { IAppBridgeMessage } from './IAppBridgeMessage';
+export declare class AppBridge {
+    readonly id: AppBridge.Id;
+    readonly role: AppBridge.Role;
+    private readonly _bridges$;
+    private readonly _messages$;
+    private readonly _state$;
+    private readonly _channel;
+    constructor(role: string);
+    get messages$(): Observable<IAppBridgeMessage<string, string>>;
+    get bridges$(): Observable<ReadonlySet<AppBridge.Id>>;
+    get bridges(): ReadonlySet<AppBridge.Id>;
+    private addBridge;
+    private removeBridge;
+    get state$(): Observable<AppBridge.State>;
+    get state(): AppBridge.State;
+    private set state(value);
+    connect(): AppBridge.DisconnectMethod;
+    send<TMessage extends IAppBridgeMessage>(args: AppBridge.SendArgs<TMessage>): void;
+}
+export declare namespace AppBridge {
+    type Id = Tagged<string, 'AppBridge.Id'>;
+    type Role = 'hub' | 'client';
+    type State = 'uninitialized' | 'initializing' | 'ready';
+    type DisconnectMethod = Callback.Void;
+    type SendArgs<TMessage extends IAppBridgeMessage> = Omit<TMessage, 'senderId' | 'sonderRole' | 'timestamp'>;
+}
+export declare function createBridgeChannel(): BroadcastChannel;

package/dist/core/bridge/AppBridge.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppBridge = void 0;
+exports.createBridgeChannel = createBridgeChannel;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const rxjs_1 = require("rxjs");
+const BridgeLifecycleMessage_1 = require("./BridgeLifecycleMessage");
+const IAppBridgeMessage_1 = require("./IAppBridgeMessage");
+// class
+class AppBridge {
+    constructor(role) {
+        // initialize instance variables
+        this.id = funnel_core_1.Value.uuid();
+        this.role = role;
+        this._bridges$ = new rxjs_1.BehaviorSubject(new Set());
+        this._messages$ = new rxjs_1.Subject();
+        this._state$ = new rxjs_1.BehaviorSubject('uninitialized');
+        this._channel = createBridgeChannel();
+    }
+    get messages$() {
+        return this._messages$.asObservable();
+    }
+    get bridges$() {
+        return this._bridges$.asObservable();
+    }
+    get bridges() {
+        return this._bridges$.value;
+    }
+    addBridge(bridge) {
+        const bridges = new Set(this.bridges);
+        bridges.add(bridge);
+        this._bridges$.next(bridges);
+    }
+    removeBridge(bridge) {
+        const bridges = new Set(this.bridges);
+        bridges.delete(bridge);
+        this._bridges$.next(bridges);
+    }
+    get state$() {
+        return this._state$.asObservable();
+    }
+    get state() {
+        return this._state$.value;
+    }
+    set state(state) {
+        this._state$.next(state);
+    }
+    connect() {
+        // throw if already connecting/connected
+        const { id, role, _messages$, _channel } = this;
+        if (this.state !== 'uninitialized') {
+            throw new funnel_core_1.InvalidOperationError('Cannot call connect() unless disconnected');
+        }
+        console.debug(`[${role}/${id}] initializing`);
+        // update state
+        this.state = 'initializing';
+        // add self to bridges
+        this.addBridge(id);
+        // create broadcast handler
+        const onChannelMessage = (event) => {
+            console.debug(`[${role}/${id}] received event`, event);
+            // ignore message if it's an echo
+            const message = event.data;
+            if (message.senderId === id) {
+                console.debug(`[${role}/${id}] ignoring echo`);
+                return;
+            }
+            // or ignore if it's directed to another bridge type
+            else if (message.recipientId && message.recipientId !== id) {
+                console.debug(`[${role}/${id}] ignoring message for recipient: `, message.recipientId);
+                return;
+            }
+            // handle bridge lifecycle events
+            if (IAppBridgeMessage_1.IAppBridgeMessage.filter(message, 'appBridge')) {
+                switch (message.type) {
+                    case 'connect': {
+                        console.debug(`[${role}/${id}] tracking connect for:`, message.senderId);
+                        // track bridge connect
+                        this.addBridge(message.senderId);
+                        // greet if hub and sender joined
+                        if (role === 'hub' && message.sonderRole === 'client') {
+                            console.debug(`[${role}/${id}] greeting client: `, message.senderId);
+                            // track client connect
+                            this.send(BridgeLifecycleMessage_1.BridgeLifecycleMessage.create({ type: 'greet', recipientId: message.senderId }));
+                        }
+                        break;
+                    }
+                    case 'greet': {
+                        // track bridge on greet
+                        this.addBridge(message.senderId);
+                        // mark client ready when greeted by hub
+                        if (role === 'client' && message.sonderRole === 'hub') {
+                            console.debug(`[${role}/${id}] received greeting from hub - marking ready`);
+                            this.state = 'ready';
+                        }
+                        // shouldn't receive greet from client (or a sibling hub)
+                        else {
+                            console.warn(`[${role}/${id}] received unexpected greeting`, message);
+                        }
+                        break;
+                    }
+                    case 'disconnect': {
+                        console.debug(`[${role}/${id}] tracking disconnect for:`, message.senderId);
+                        // remove bridge on disconnect
+                        this.removeBridge(message.senderId);
+                        break;
+                    }
+                }
+            }
+            else {
+                console.debug(`[${role}/${id}] message is not a lifecycle message`, message);
+            }
+            // forward locally
+            _messages$.next(message);
+        };
+        // listen to messages and forward all to the channel
+        _channel.addEventListener('message', onChannelMessage);
+        console.debug(`[${role}/${id}] broadcasting connect`);
+        // broadcast connect
+        this.send(BridgeLifecycleMessage_1.BridgeLifecycleMessage.create({ type: 'connect' }));
+        // broadcast greet (if we're the hub)
+        if (role === 'hub') {
+            console.debug(`[${role}/${id}] broadcasting greet`);
+            // greet
+            this.send(BridgeLifecycleMessage_1.BridgeLifecycleMessage.create({ type: 'greet' }));
+            // mark ready
+            this.state = 'ready';
+        }
+        // return disconnect handler
+        return () => {
+            console.debug(`[${role}/${id}] broadcasting disconnect`);
+            // stop listening
+            _channel.removeEventListener('message', onChannelMessage);
+            // broadcast disconnect
+            this.send(BridgeLifecycleMessage_1.BridgeLifecycleMessage.create({ type: 'disconnect' }));
+        };
+    }
+    send(args) {
+        // create full message
+        const { id, role, _messages$, _channel } = this;
+        const message = Object.assign({ senderId: id, sonderRole: role, timestamp: Date.now() }, args);
+        // post locally
+        _messages$.next(message);
+        _channel.postMessage(message);
+    }
+}
+exports.AppBridge = AppBridge;
+// helpers
+const CHANNEL_PREFIX = 'funnel:channel:';
+const CHANNEL_ID_KEY = 'funnel:appBridge:channelId';
+function createBridgeChannel() {
+    // fetch channel id (or create one)
+    let channelId = window.sessionStorage.getItem(CHANNEL_ID_KEY);
+    if (!channelId) {
+        channelId = funnel_core_1.Value.uuid();
+        window.sessionStorage.setItem(CHANNEL_ID_KEY, channelId);
+    }
+    // create broadcast channel for bridge
+    return new BroadcastChannel(`'${CHANNEL_PREFIX}${channelId}`);
+}

package/dist/core/bridge/AppBridgeContainer.d.ts

@@ -1,9 +1,9 @@
 import { ReactNode } from 'react';
-export declare const CHANNEL_PREFIX = "funnel:channel:";
-export declare function AppBridgeContainer({ children }: AppBridgeContainer.Props): import("react/jsx-runtime").JSX.Element;
+import { AppBridge } from './AppBridge';
+export declare function AppBridgeContainer({ role, children }: AppBridgeContainer.Props): import("react/jsx-runtime").JSX.Element;
 export declare namespace AppBridgeContainer {
     type Props = {
+        role: AppBridge.Role;
         children: ReactNode;
     };
 }
-export declare function getUniqueId(): string;

package/dist/core/bridge/AppBridgeContainer.js

@@ -1,55 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CHANNEL_PREFIX = void 0;
 exports.AppBridgeContainer = AppBridgeContainer;
-exports.getUniqueId = getUniqueId;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
-const rxjs_1 = require("rxjs");
-const uuid_1 = require("uuid");
+const AppBridge_1 = require("./AppBridge");
 const AppBridgeContext_1 = require("./AppBridgeContext");
-// constants
-exports.CHANNEL_PREFIX = 'funnel:channel:';
 // container
-function AppBridgeContainer({ children }) {
-    // create context
-    const context = (0, react_1.useMemo)(() => ({
-        id: (0, uuid_1.v4)(),
-        eventBus: new rxjs_1.Subject(),
-        channel: new BroadcastChannel(exports.CHANNEL_PREFIX + getUniqueId())
-    }), []);
-    // forward all events to channel
+function AppBridgeContainer({ role, children }) {
+    // bind bridge/context
+    const appBridge = (0, react_1.useMemo)(() => new AppBridge_1.AppBridge(role), [role]);
+    const context = (0, react_1.useMemo)(() => ({ appBridge }), [appBridge]);
+    // connect on mount (automatically disconnects b/c of result
     (0, react_1.useEffect)(() => {
-        // create message handler
-        const { id, eventBus, channel } = context;
-        const onChannelMessage = (event) => {
-            console.debug(`[${id}] received event`, event);
-            // ignore message if sent from this container
-            const message = event.data;
-            if (message.source === id) {
-                console.debug(`[${id}] ignoring echo`);
-                return;
-            }
-            console.debug(`[${id}] forwarding message to local bus`);
-            eventBus.next(message);
-        };
-        // listen to messages and forward all to the channel
-        channel.addEventListener('message', onChannelMessage);
-        // remove listener on unmount
-        return () => channel.removeEventListener('message', onChannelMessage);
-    }, [context]);
+        return appBridge.connect();
+    }, [appBridge]);
     // render
     return ((0, jsx_runtime_1.jsx)(AppBridgeContext_1.AppBridgeContext.Provider, { value: context, children: children }));
 }
-// helpers
-const UUID_KEY = 'funnel:uuid';
-function getUniqueId() {
-    // fetch window id (or create one)
-    let value = window.sessionStorage.getItem(UUID_KEY);
-    if (!value) {
-        value = (0, uuid_1.v4)();
-        window.sessionStorage.setItem(UUID_KEY, value);
-    }
-    // return value
-    return value;
-}

package/dist/core/bridge/AppBridgeContext.d.ts

@@ -1,8 +1,7 @@
-import { Subject } from 'rxjs';
-import { AppContextId, TrackedAppMessage } from './AppMessage';
-export type IAppBridgeContext = {
-    id: AppContextId;
-    eventBus: Subject<TrackedAppMessage>;
-    channel: BroadcastChannel;
-};
-export declare const AppBridgeContext: import("react").Context<IAppBridgeContext>;
+import { AppBridge } from './AppBridge';
+export declare const AppBridgeContext: import("react").Context<AppBridgeContext.Data>;
+export declare namespace AppBridgeContext {
+    type Data = {
+        appBridge?: AppBridge;
+    };
+}

package/dist/core/bridge/AppBridgeContext.js

@@ -2,10 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppBridgeContext = void 0;
 const react_1 = require("react");
-const rxjs_1 = require("rxjs");
 // context
-exports.AppBridgeContext = (0, react_1.createContext)({
-    id: '',
-    eventBus: new rxjs_1.Subject(),
-    channel: {}
-});
+exports.AppBridgeContext = (0, react_1.createContext)({});

package/dist/core/bridge/BridgeLifecycleMessage.d.ts

@@ -0,0 +1,7 @@
+import type { IAppBridgeMessage } from './IAppBridgeMessage';
+export interface BridgeLifecycleMessage extends IAppBridgeMessage<'appBridge', BridgeLifecycleMessage.Type> {
+}
+export declare namespace BridgeLifecycleMessage {
+    type Type = 'connect' | 'greet' | 'disconnect';
+    function create(args: IAppBridgeMessage.Create.Args<BridgeLifecycleMessage>): IAppBridgeMessage.Create.Result<BridgeLifecycleMessage>;
+}

package/dist/core/bridge/BridgeLifecycleMessage.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeLifecycleMessage = void 0;
+// extensions
+var BridgeLifecycleMessage;
+(function (BridgeLifecycleMessage) {
+    // helpers
+    function create(args) {
+        return Object.assign(Object.assign({}, args), { domain: 'appBridge' });
+    }
+    BridgeLifecycleMessage.create = create;
+})(BridgeLifecycleMessage || (exports.BridgeLifecycleMessage = BridgeLifecycleMessage = {}));

package/dist/core/bridge/IAppBridgeMessage.d.ts

@@ -0,0 +1,16 @@
+import type { AppBridge } from './AppBridge';
+export interface IAppBridgeMessage<TDomain extends string = string, TType extends string = string> {
+    senderId: AppBridge.Id;
+    sonderRole: AppBridge.Role;
+    recipientId?: AppBridge.Id;
+    domain: TDomain;
+    type: TType;
+    timestamp: number;
+}
+export declare namespace IAppBridgeMessage {
+    namespace Create {
+        type Args<TMessage extends IAppBridgeMessage> = Omit<TMessage, 'senderId' | 'sonderRole' | 'domain' | 'timestamp'>;
+        type Result<TMessage extends IAppBridgeMessage> = Omit<TMessage, 'senderId' | 'senderRole' | 'timestamp'>;
+    }
+    function filter<TTMessage extends IAppBridgeMessage>(message: IAppBridgeMessage, domain: TTMessage['domain'], type?: TTMessage['type']): message is TTMessage;
+}

package/dist/core/bridge/IAppBridgeMessage.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IAppBridgeMessage = void 0;
+// extensions
+var IAppBridgeMessage;
+(function (IAppBridgeMessage) {
+    function filter(message, domain, type) {
+        return message.domain === domain
+            && (!type || message.type === type);
+    }
+    IAppBridgeMessage.filter = filter;
+})(IAppBridgeMessage || (exports.IAppBridgeMessage = IAppBridgeMessage = {}));

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

@@ -1,4 +1,5 @@
+export * from './AppBridge';
+export * from './IAppBridgeMessage';
 export * from './AppBridgeContainer';
 export * from './AppBridgeContext';
-export * from './AppMessage';
 export * from './useAppBridge';

package/dist/core/bridge/index.js

@@ -14,7 +14,8 @@ 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("./AppBridge"), exports);
+__exportStar(require("./IAppBridgeMessage"), exports);
 __exportStar(require("./AppBridgeContainer"), exports);
 __exportStar(require("./AppBridgeContext"), exports);
-__exportStar(require("./AppMessage"), exports);
 __exportStar(require("./useAppBridge"), exports);