@nascentdigital/funnel-editor-contentful 4.6.7 → 5.0.2

package/dist/collection/repository/CollectionRepository.js

@@ -0,0 +1,210 @@
+"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) {
+        // throw if entry isn't a collection (it should be in this case)
+        const { sdk, contentfulClient } = this;
+        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(Object.assign({ data }, references));
+        return {
+            collectionGroup: new components_1.CollectionGroup(Object.assign({ template: collection.template, collections }, group)),
+            collection,
+            sys
+        };
+    }
+    async save(collection) {
+        // 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 { sdk } = this;
+        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);
+                collection = domain_1.Collection.fromSchemaData(result.collection);
+            }
+        }
+        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 }) {
+        // skip if entity version and updated sys are same
+        const { sdk } = this;
+        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(Object.assign({ 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/collection/repository/index.js

@@ -0,0 +1,17 @@
+"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("./CollectionRepository"), exports);

package/dist/collection/screens/CollectionEditor.d.ts

@@ -0,0 +1 @@
+export declare function CollectionEditor(): import("react/jsx-runtime").JSX.Element;

package/dist/collection/screens/CollectionEditor.js

@@ -0,0 +1,59 @@
+"use strict";
+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 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(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.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
+    const { ready, collectionGroup, collection } = controller;
+    if (!ready) {
+        return ((0, jsx_runtime_1.jsx)(components_1.Loader, {}, "loader"));
+    }
+    // render error if there's no group
+    else if (!collectionGroup) {
+        return ((0, jsx_runtime_1.jsx)(components_1.EmptyState, { variant: "missing", size: "md", children: "Oops!  This page doesn't seem to exist..." }));
+    }
+    // render create state if there's no group
+    else if (!collection) {
+        return null;
+    }
+    // otherwise render editor
+    else {
+        return ((0, jsx_runtime_1.jsx)("div", { className: "flex-1 flex flex-col gap-l10 px-l6 py-l10 overflow-y-scroll scrollbar-thin bg-background", children: (0, jsx_runtime_1.jsx)(components_1.FieldsPanel, { title: "Content", fields: collection.allFields }) }));
+    }
+}

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

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

package/dist/collection/screens/index.js

@@ -0,0 +1,17 @@
+"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("./CollectionEditor"), exports);

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

@@ -0,0 +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;
+export declare namespace AppBridgeContainer {
+    type Props = {
+        children: ReactNode;
+    };
+}
+export declare function getUniqueId(): string;

package/dist/core/bridge/AppBridgeContainer.js

@@ -0,0 +1,55 @@
+"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 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
+    (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]);
+    // 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

@@ -0,0 +1,8 @@
+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>;

package/dist/core/bridge/AppBridgeContext.js

@@ -0,0 +1,11 @@
+"use strict";
+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: {}
+});

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

@@ -0,0 +1,19 @@
+import { Tagged } from 'type-fest';
+export type AppDomain = 'app';
+export interface AppMessage {
+    domain: AppDomain;
+    type: string;
+    timestamp: number;
+}
+export type AppContextId = Tagged<string, 'funnel.AppContextId'>;
+export interface TrackedAppMessage extends AppMessage {
+    source: AppContextId;
+}
+export interface AppBlockNavMessage extends AppMessage {
+    type: 'blockNav';
+    itemId: string;
+}
+export declare namespace AppBlockNavMessage {
+    function create(itemId: string): AppBlockNavMessage;
+    function guard(message: AppMessage): message is AppBlockNavMessage;
+}

package/dist/core/bridge/AppMessage.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppBlockNavMessage = void 0;
+var AppBlockNavMessage;
+(function (AppBlockNavMessage) {
+    function create(itemId) {
+        return {
+            domain: 'app',
+            type: 'blockNav',
+            timestamp: Date.now(),
+            itemId
+        };
+    }
+    AppBlockNavMessage.create = create;
+    function guard(message) {
+        return message.domain === 'app' && message.type === 'blockNav';
+    }
+    AppBlockNavMessage.guard = guard;
+})(AppBlockNavMessage || (exports.AppBlockNavMessage = AppBlockNavMessage = {}));

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

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

package/dist/core/bridge/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 });
+__exportStar(require("./AppBridgeContainer"), exports);
+__exportStar(require("./AppBridgeContext"), exports);
+__exportStar(require("./AppMessage"), exports);
+__exportStar(require("./useAppBridge"), exports);

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

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+import { AppMessage } from './AppMessage';
+export type AppMessageSubmission = Omit<AppMessage, 'source'>;
+export type UseAppBridgetHook = {
+    sendMessage(message: AppMessageSubmission): void;
+    messages$: Observable<AppMessage>;
+};
+export declare function useAppBridge(): UseAppBridgetHook;

package/dist/core/bridge/useAppBridge.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAppBridge = useAppBridge;
+const react_1 = require("react");
+const AppBridgeContext_1 = require("./AppBridgeContext");
+// hook
+function useAppBridge() {
+    // bind context
+    const { id, eventBus, channel } = (0, react_1.useContext)(AppBridgeContext_1.AppBridgeContext);
+    // helpers
+    const sendMessage = (message) => {
+        // track the message
+        const trackedMessage = Object.assign({ source: id }, message);
+        // send to local bus
+        eventBus.next(trackedMessage);
+        // echo to remote bus (if any)
+        channel.postMessage(trackedMessage);
+    };
+    // return hook interface
+    return {
+        sendMessage,
+        messages$: eventBus.asObservable()
+    };
+}

package/dist/core/client/ContentfulClientContainer.d.ts

@@ -0,0 +1,8 @@
+import { KnownAppSDK } from '@contentful/app-sdk';
+import { PropsWithChildren } from 'react';
+export declare function ContentfulClientContainer({ sdk, children }: ContentfulClientContainer.Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace ContentfulClientContainer {
+    type Props = PropsWithChildren & {
+        sdk: KnownAppSDK;
+    };
+}

package/dist/core/client/ContentfulClientContainer.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulClientContainer = ContentfulClientContainer;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const contentful_1 = require("@nascentdigital/funnel-cms/contentful");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const react_1 = require("react");
+const ContentfulClientContext_1 = require("./ContentfulClientContext");
+// container
+function ContentfulClientContainer({ sdk, children }) {
+    // bind state
+    const [client, setClient] = (0, react_1.useState)(() => ({ __type: 'pending' }));
+    const context = (0, react_1.useMemo)(() => ({ client }), [client]);
+    // create client on mount
+    (0, react_1.useEffect)(() => {
+        // fetch client
+        let cancelled = false;
+        const mount = async () => {
+            // try to create
+            try {
+                // create editor
+                const client = await contentful_1.ContentfulContentClient.forEditor(sdk);
+                // bind if not cancelled
+                if (!cancelled) {
+                    setClient({ __type: 'success', result: client });
+                }
+            }
+            // or handle error (if not cancelled)
+            catch (e) {
+                if (!cancelled) {
+                    setClient({ __type: 'failure', error: funnel_core_1.IsometricErrorUtils.coerceError(e) });
+                }
+            }
+        };
+        mount().catch(console.error);
+        // cancel on unmount
+        return () => {
+            cancelled = true;
+        };
+    }, [sdk]);
+    // render
+    return ((0, jsx_runtime_1.jsx)(ContentfulClientContext_1.ContentfulClientContext.Provider, { value: context, children: client.__type === 'success' && children }));
+}

package/dist/core/client/ContentfulClientContext.d.ts

@@ -0,0 +1,8 @@
+import { ContentfulContentClient } from '@nascentdigital/funnel-cms/contentful';
+import { Result } from '@nascentdigital/funnel-core';
+export declare const ContentfulClientContext: import("react").Context<ContentfulClientContext.Data>;
+export declare namespace ContentfulClientContext {
+    type Data = {
+        client: Result<ContentfulContentClient>;
+    };
+}

package/dist/core/client/ContentfulClientContext.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulClientContext = void 0;
+const react_1 = require("react");
+// context
+exports.ContentfulClientContext = (0, react_1.createContext)({
+    client: { __type: 'pending' }
+});

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

@@ -0,0 +1,3 @@
+export * from './ContentfulClientContainer';
+export * from './ContentfulClientContext';
+export * from './useContentfulClient';

package/dist/core/client/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("./ContentfulClientContainer"), exports);
+__exportStar(require("./ContentfulClientContext"), exports);
+__exportStar(require("./useContentfulClient"), exports);

package/dist/core/client/useContentfulClient.d.ts

@@ -0,0 +1,4 @@
+import { ContentfulContentClient } from '@nascentdigital/funnel-cms/contentful';
+import { Result } from '@nascentdigital/funnel-core';
+export declare function usePossibleContentfulClient(): Result<ContentfulContentClient>;
+export declare function useContentfulClient(): ContentfulContentClient;

package/dist/core/client/useContentfulClient.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePossibleContentfulClient = usePossibleContentfulClient;
+exports.useContentfulClient = useContentfulClient;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const react_1 = require("react");
+const ContentfulClientContext_1 = require("./ContentfulClientContext");
+// hooks
+function usePossibleContentfulClient() {
+    // bind context
+    const { client } = (0, react_1.useContext)(ContentfulClientContext_1.ContentfulClientContext);
+    // return result
+    return client;
+}
+function useContentfulClient() {
+    // bind context
+    const { client } = (0, react_1.useContext)(ContentfulClientContext_1.ContentfulClientContext);
+    // throw if unavailable (shouldn't happen - see ContentfulClientContainer)
+    if (client.__type !== 'success') {
+        throw new funnel_core_1.IllegalStateError('ContentfulContentClient isn\'t available');
+    }
+    // return result
+    return client.result;
+}