@nascentdigital/funnel-editor-contentful 5.0.1 → 5.0.2

package/dist/page/controller/ContentfulPageController.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulPageController = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const rxjs_1 = require("rxjs");
+// class
+class ContentfulPageController {
+    constructor(args) {
+        // initialize instance variables
+        this.pageRepository = args.pageRepository;
+        this._eventBus = new funnel_core_1.EventBus();
+        this._state = 'uninitialized';
+    }
+    get events$() {
+        return this._eventBus.events$.pipe((0, rxjs_1.filter)((e) => components_1.IPageController.Event.filter(e) || components_1.IPage.Event.filter(e)));
+    }
+    get saved$() {
+        return this._eventBus.events$.pipe((0, rxjs_1.filter)(components_1.IPageController.StateChangedEvent.filter), (0, rxjs_1.pairwise)(), (0, rxjs_1.filter)(([previous, current]) => previous.state === 'saving' && current.state === 'ready'));
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        // skip if unchanged
+        if (this._state === value) {
+            return;
+        }
+        // or update
+        this._state = value;
+        // raise event
+        this._eventBus.publish(components_1.IPageController.StateChangedEvent.create({
+            state: value,
+            controller: this
+        }));
+        // process queues if ready (might be noop)
+        if (value === 'ready') {
+            this.processQueues().catch(console.error);
+        }
+    }
+    get ready() {
+        const { _state } = this;
+        return _state !== 'uninitialized' && _state !== 'initializing';
+    }
+    get languages() {
+        var _a, _b;
+        return (_b = (_a = this._pageSummary) === null || _a === void 0 ? void 0 : _a.pages.map(page => page.language)) !== null && _b !== void 0 ? _b : [];
+    }
+    get pageSummary() {
+        return this._pageSummary;
+    }
+    set pageSummary(pageSummary) {
+        // skip if summary is the same
+        if (this._pageSummary === pageSummary) {
+            return;
+        }
+        // update summary
+        this._pageSummary = pageSummary;
+        // raise event
+        this.raiseEvent('pageSummary.changed');
+    }
+    get page() {
+        return this._page;
+    }
+    set page(page) {
+        // skip if page is the same
+        if (this._page === page) {
+            console.debug('[ContentfulPageController/setPage] skipping page set, same instance');
+            return;
+        }
+        // unbind previous page subscription (if any)
+        if (this._pageSubscription) {
+            this._pageSubscription.unsubscribe();
+            delete this._pageSubscription;
+        }
+        console.debug('[ContentfulPageController/setPage] new page instance set');
+        // update page
+        this._page = page;
+        // subscribe to page changes
+        if (page) {
+            // subscribe to page events
+            this._pageSubscription = page.events$
+                .pipe((0, rxjs_1.filter)(e => {
+                // handle page events
+                if (components_1.IPage.Event.filter(e)) {
+                    return e.type === 'modified';
+                }
+                // or item/object/list events
+                else if (components_1.Item.Event.filter(e)
+                    || components_1.Item.Event.filter(e)
+                    || funnel_core_1.ObjectField.Event.filter(e)
+                    || funnel_core_1.FieldList.Event.filter(e)) {
+                    return e.type === 'changed';
+                }
+                // or field
+                else {
+                    return funnel_core_1.Field.Event.filter(e) && (e.type === 'changed' || e.type === 'reset');
+                }
+            }), (0, rxjs_1.debounce)(e => {
+                return (0, rxjs_1.interval)(1000);
+            }))
+                .subscribe(async (e) => {
+                if (page.modified && this._page === page) {
+                    await this.save(page);
+                }
+            });
+        }
+        // raise state change
+        this.raiseEvent('page.changed');
+    }
+    get pageSys() {
+        return this._pageSys;
+    }
+    set pageSys(sys) {
+        this._pageSys = sys;
+    }
+    async sync(updatedSys) {
+        // skip if there's no active page/sys
+        const { page, pageSys, state, pageRepository } = this;
+        if (!page || !pageSys) {
+            console.warn('[ContentfulPageController/sync] ignoring update before initial load');
+            return;
+        }
+        // or skip if page version is unchanged
+        else if (page.id === updatedSys.id && pageSys.version >= updatedSys.version) {
+            console.debug('[ContentfulPageController/sync] ignoring update - current version is fresh');
+            return;
+        }
+        // or ignore if booting up
+        else if (state === 'uninitialized' || state === 'initializing' || state === 'loading') {
+            console.debug('[ContentfulPageController/sync] ignoring sync while loading');
+            return;
+        }
+        // or queue if saving
+        else if (this.state === 'saving') {
+            console.debug('[ContentfulPageController/sync] queueing page sync - updated while saving');
+            this._queuedSync = updatedSys;
+            return;
+        }
+        // try to sync
+        try {
+            console.debug('[ContentfulPageController/sync] starting sync');
+            // update state
+            this.state = 'loading';
+            // perform sync
+            const result = await pageRepository.sync({ page, sys: updatedSys });
+            // update sys
+            this.pageSys = result.sys;
+            // update page (if unchanged)
+            if (this.page !== result.page) {
+                this.page = result.page;
+            }
+            // update summary (if any)
+            if (result.pageSummary) {
+                this.pageSummary = result.pageSummary;
+            }
+            console.debug('[ContentfulPageController/sync] sync complete');
+            // clear state
+            this.state = 'ready';
+        }
+        // catch error
+        catch (e) {
+            console.error('[ContentfulPageController/sync] sync failed', e);
+            this.state = 'error';
+        }
+    }
+    async load() {
+        // mark as loading (or initialing if loading for first time)
+        this.state = this._state === 'uninitialized'
+            ? 'initializing'
+            : 'loading';
+        // try to load page
+        try {
+            // fetch page
+            const { pageSummary, page, sys } = await this.pageRepository.load();
+            console.debug('[ContentfulPageController/load] fetched page', { pageSummary, page, sys });
+            // set page/summary
+            this.pageSummary = pageSummary;
+            this.page = page;
+            this._pageSys = sys;
+            // update state
+            this.state = 'ready';
+        }
+        // handle error
+        catch (e) {
+            console.error('[ContentfulPageController/load] failed to load page', e);
+            // set error state
+            this.state = 'error';
+        }
+    }
+    async create(target) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async save(page) {
+        // ignore if not ready
+        if (this._state !== 'ready') {
+            console.debug(`[ContentfulPageController/save] queuing save while in "${this._state}" state`);
+            this._queuedSave = page;
+            return;
+        }
+        // clear save if queued
+        delete this._queuedSave;
+        // skip if page isn't modified
+        if (!page.modified) {
+            console.debug('[ContentfulPageController/save] ignore unmodified page');
+            return;
+        }
+        // try to save page
+        try {
+            console.debug('[ContentfulPageController/save] starting save');
+            // mark as syncing
+            page.syncing = true;
+            // update state
+            this.state = 'saving';
+            // save page
+            this.page = await this.pageRepository.save(page);
+            // update state
+            this.state = 'ready';
+            console.debug('[ContentfulPageController/save] save finished');
+        }
+        // handle error
+        catch (e) {
+            console.error('[ContentfulPageController/save] save failed', e);
+            // update state
+            this.state = 'error';
+        }
+        // complete
+        finally {
+            page.syncing = false;
+        }
+    }
+    async reload() {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async unpublish() {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async processQueues() {
+        // try to save (if queued)
+        const { _queuedSave, _page } = this;
+        if (_queuedSave) {
+            // nuke if page differs (keep going afterward)
+            if (_page !== _queuedSave) {
+                console.debug('[ContentfulPageController/processQueues] ignoring queued save for old page');
+                delete this._queuedSave;
+            }
+            // otherwise, try to save
+            else {
+                console.debug('[ContentfulPageController/processQueues] restarting queued save');
+                // save
+                this.save(_page).catch(console.error);
+                // stop processing
+                return;
+            }
+        }
+        // try to sync
+        const { _queuedSync, _pageSys } = this;
+        if (_queuedSync) {
+            // clear sync
+            delete this._queuedSync;
+            // reload if entity is different
+            if (_queuedSync.id !== (_pageSys === null || _pageSys === void 0 ? void 0 : _pageSys.id)) {
+                console.debug('[ContentfulPageController/processQueues] reloading on entity change');
+                this.load().catch(console.error);
+            }
+            // otherwise, try to sync
+            else {
+                console.debug('[ContentfulPageController/processQueues] retrying sync');
+                this.sync(_queuedSync).catch(console.error);
+            }
+        }
+    }
+    raiseEvent(type) {
+        this._eventBus.publish(components_1.IPageController.Event.create({ type, controller: this }));
+    }
+}
+exports.ContentfulPageController = ContentfulPageController;

package/dist/page/controller/ContentfulPageControllerContainer.d.ts

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

package/dist/page/controller/ContentfulPageControllerContainer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulPageControllerContainer = ContentfulPageControllerContainer;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_apps_toolkit_1 = require("@contentful/react-apps-toolkit");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const react_1 = require("react");
+const ContentfulPageController_1 = require("./ContentfulPageController");
+// container
+function ContentfulPageControllerContainer({ children }) {
+    // bind context
+    const pageRepository = (0, components_1.usePageRepository)();
+    const sdk = (0, react_apps_toolkit_1.useSDK)();
+    const context = (0, react_1.useMemo)(() => ({
+        controller: new ContentfulPageController_1.ContentfulPageController({ pageRepository })
+    }), [pageRepository]);
+    // listen to page changes
+    (0, react_1.useEffect)(() => {
+        // get controller
+        const { controller } = context;
+        // sync on change (return unsubscribe)
+        return sdk.entry.onSysChanged(sys => {
+            controller.sync(sys).catch(console.error);
+        });
+    }, [sdk, context]);
+    // render
+    return ((0, jsx_runtime_1.jsx)(components_1.PageControllerContext.Provider, { value: context, children: children }));
+}

package/dist/page/controller/index.d.ts

@@ -1,3 +1,3 @@
-export * from './LocalPageController';
-export * from './LocalPageControllerContainer';
-export * from './useLocalPageController';
+export * from './ContentfulPageController';
+export * from './ContentfulPageControllerContainer';
+export * from './useContentfulPageController';

package/dist/page/controller/index.js

@@ -14,6 +14,6 @@ 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("./LocalPageController"), exports);
-__exportStar(require("./LocalPageControllerContainer"), exports);
-__exportStar(require("./useLocalPageController"), exports);
+__exportStar(require("./ContentfulPageController"), exports);
+__exportStar(require("./ContentfulPageControllerContainer"), exports);
+__exportStar(require("./useContentfulPageController"), exports);

package/dist/page/controller/useContentfulPageController.d.ts

@@ -0,0 +1,2 @@
+import { ContentfulPageController } from './ContentfulPageController';
+export declare function useContentfulPageController(): ContentfulPageController;

package/dist/page/controller/useContentfulPageController.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContentfulPageController = useContentfulPageController;
+const components_1 = require("@nascentdigital/funnel-editor/components");
+// hook
+function useContentfulPageController() {
+    return (0, components_1.usePageController)();
+}

package/dist/{core → page}/domain/Page.d.ts

@@ -1,4 +1,5 @@
-import { AssetClient } from '@nascentdigital/funnel-cms';
+import { AssetClient, PageClient } from '@nascentdigital/funnel-cms';
+import { ContentfulData, ContentfulPageData } from '@nascentdigital/funnel-cms/contentful';
 import { EventBus, FieldModel, Language, Schema } from '@nascentdigital/funnel-core';
 import { Asset, Block, IPage, PageSettings, Section, SectionBlock } from '@nascentdigital/funnel-editor/components';
 import { Observable } from 'rxjs';
@@ -35,6 +36,7 @@ export declare class Page implements IPage {
     private _syncing;
     private readonly _subscription;
     private _savingOn?;
+    readonly references: ReadonlyArray<ContentfulData.Link.Entry | ContentfulData.Link.Asset>;
     constructor(args: Page.ConstructorArgs);
     get events$(): Observable<IPage.Events>;
     get stable$(): Observable<boolean>;
@@ -75,6 +77,7 @@ export declare class Page implements IPage {
     get items(): Array<Block | Section>;
     get assets(): Asset[];
     get collections(): ReadonlyArray<Schema.Collection.Data.AsLink>;
+    get pages(): ReadonlyArray<Schema.Page.Data.AsRef>;
     get initialTags(): ReadonlySet<Schema.Tag<string, string>>;
     get tagGroups(): ReadonlyArray<Schema.TagGroup>;
     get tags(): ReadonlySet<Schema.Tag>;
@@ -101,6 +104,17 @@ export declare class Page implements IPage {
     private raiseEvent;
 }
 export declare namespace Page {
+    type Blocks = Block[];
+    type Content = Array<Block | Section>;
+    type Errors = {
+        page: Page;
+        items: Array<Block | Section>;
+    };
+    type Changes = {
+        page: Page;
+        items: Array<Block | Section>;
+    };
+    type Target = Block | SectionBlock | Section | FieldModel;
     type ConstructorArgs = {
         template: Schema.Page;
         eventBus: EventBus;
@@ -124,16 +138,13 @@ export declare namespace Page {
         updatedOn: number;
         publishedOn?: number;
         publication?: number;
+        references: ContentfulData.References;
     };
-    type Blocks = Block[];
-    type Content = Array<Block | Section>;
-    type Errors = {
-        page: Page;
-        items: Array<Block | Section>;
+    type FromSchemaData = {
+        data: ContentfulPageData.ForSchema;
+        references?: Schema.Page.References;
+        eventBus?: EventBus;
     };
-    type Changes = {
-        page: Page;
-        items: Array<Block | Section>;
-    };
-    type Target = Block | SectionBlock | Section | FieldModel;
+    function fromSchemaData({ data, references, eventBus }: FromSchemaData): Page;
+    function toUpdates(page: Page, savables: IPage.Savable[]): PageClient.Update.Args;
 }

package/dist/{core → page}/domain/Page.js

@@ -1,4 +1,15 @@
 "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.Page = void 0;
 const funnel_core_1 = require("@nascentdigital/funnel-core");
@@ -33,6 +44,7 @@ class Page {
         this._collections = (_c = args.collections) !== null && _c !== void 0 ? _c : [];
         this._initialTags = new Set(args.tags);
         this._tags = new Set(args.tags);
+        this.references = args.references;
         this._deletedBlocks = [];
         this._syncing = false;
         // bind content
@@ -253,6 +265,9 @@ class Page {
     get collections() {
         return this._collections;
     }
+    get pages() {
+        return this._pages;
+    }
     get initialTags() {
         return this._initialTags;
     }
@@ -491,3 +506,126 @@ class Page {
     }
 }
 exports.Page = Page;
+// extension
+(function (Page) {
+    function fromSchemaData({ data, references, eventBus }) {
+        // setup
+        const { snapshot, discover, content, tags } = data, pageArgs = __rest(data, ["snapshot", "discover", "content", "tags"]);
+        const { files = {}, collections = {}, pages = {} } = references !== null && references !== void 0 ? references : {};
+        const { discover: discoverSnapshot = {}, content: contentSnapshot = {} } = snapshot !== null && snapshot !== void 0 ? snapshot : {};
+        const template = funnel_core_1.Schema.Site.getPage(data.type, data.region);
+        eventBus = eventBus !== null && eventBus !== void 0 ? eventBus : new funnel_core_1.EventBus();
+        // create page
+        return new Page(Object.assign(Object.assign({}, pageArgs), { eventBus,
+            template, tags: components_1.TagSerializer.deserializeTags({
+                groups: template.tags,
+                tagsData: tags !== null && tags !== void 0 ? tags : []
+            }), discover: [
+                components_1.PageSerializer.deserializeBlock({
+                    schema: funnel_core_1.Schema.Seo,
+                    eventBus,
+                    key: 'seo',
+                    content: discover['seo'],
+                    snapshot: discoverSnapshot['seo']
+                })
+            ], content: Object.entries(template.content).map(([key, schema]) => components_1.PageSerializer.deserializeContent({
+                key,
+                schema: schema.unwrap(),
+                eventBus,
+                content: content[key],
+                snapshot: contentSnapshot[key],
+            })), files: Object.values(files), collections: Object.values(collections), pages: Object.values(pages) }));
+    }
+    Page.fromSchemaData = fromSchemaData;
+    function toUpdates(page, savables) {
+        var _a, _b;
+        // root page updates
+        const { id, discover, content } = page;
+        const rootPageUpdates = [];
+        // name
+        if (page.initialName !== page.name) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'name',
+                value: page.name
+            });
+        }
+        // tags
+        if (page.initialTags.symmetricDifference(page.tags).size > 0) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'tags',
+                value: Array.from(page.tags).map(tag => tag.data)
+            });
+        }
+        // slug + url
+        if (page.initialSlug !== page.slug) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'slug',
+                value: (_a = page.slug) !== null && _a !== void 0 ? _a : null
+            });
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'url',
+                value: page.url
+            });
+        }
+        // preview
+        const previewBlock = page.getPreviewBlock();
+        if (previewBlock && previewBlock.modified) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'preview',
+                value: previewBlock.value
+            });
+        }
+        // errors
+        if (page.initialErrors !== !page.valid) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'errors',
+                value: !page.valid
+            });
+        }
+        // publication
+        if (page.initialPublication !== page.publication) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'publication',
+                value: (_b = page.publication) !== null && _b !== void 0 ? _b : null
+            });
+        }
+        // aggregate other updates
+        return {
+            id,
+            updatedOn: page.updatedOn,
+            updates: [
+                ...rootPageUpdates,
+                ...discover.reduce((updates, block) => {
+                    // try to update block
+                    components_1.SerializePageUpdate.serializeBlockUpdate(updates, block, 'discover', savables);
+                    // keep reducing
+                    return updates;
+                }, []),
+                ...content.reduce((updates, item) => {
+                    // handle block
+                    if (item instanceof components_1.Block) {
+                        components_1.SerializePageUpdate.serializeBlockUpdate(updates, item, 'content', savables);
+                    }
+                    // or section
+                    else {
+                        components_1.SerializePageUpdate.serializeSectionUpdate(updates, item, 'content', savables);
+                    }
+                    // keep reducing
+                    return updates;
+                }, []),
+                ...page.deleteBlocks.map(block => ({
+                    type: 'block.delete',
+                    path: [block.area, block.key]
+                }))
+            ]
+        };
+    }
+    Page.toUpdates = toUpdates;
+})(Page || (exports.Page = Page = {}));

package/dist/page/domain/index.d.ts

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

package/dist/page/domain/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("./Page"), exports);

package/dist/page/index.d.ts

@@ -1,2 +1,4 @@
+export * from './domain';
+export * from './repository';
 export * from './screens';
 export * from './controller';

package/dist/page/index.js

@@ -14,5 +14,7 @@ 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("./repository"), exports);
 __exportStar(require("./screens"), exports);
 __exportStar(require("./controller"), exports);

package/dist/page/repository/PageRepository.d.ts

@@ -0,0 +1,45 @@
+import { EditorAppSDK, EntrySys } from '@contentful/app-sdk';
+import { ContentfulContentClient } from '@nascentdigital/funnel-cms/contentful';
+import { Schema } from '@nascentdigital/funnel-core';
+import { IPage, IPageRepository, PageSummary } from '@nascentdigital/funnel-editor/components';
+import { Page } from '../domain';
+export declare class PageRepository implements IPageRepository {
+    readonly sdk: EditorAppSDK;
+    readonly contentfulClient: ContentfulContentClient;
+    constructor(args: PageRepository.ConstructorArgs);
+    search(args: IPageRepository.Search.Args): Promise<IPageRepository.Search.Result>;
+    getOverview({ region }: IPageRepository.GetOverview.Args): Promise<IPageRepository.GetOverview.Result>;
+    create(args: IPageRepository.Create.Args): Promise<IPageRepository.Create.Result>;
+    createLanguage(args: IPageRepository.CreateLang.Args): Promise<IPageRepository.CreateLang.Result>;
+    load(sys?: EntrySys): Promise<PageRepository.Load.Result>;
+    save(page: Page): Promise<Page>;
+    sync({ page, sys }: PageRepository.Sync.Args): Promise<PageRepository.Sync.Result>;
+    unpublish(page: IPage): Promise<void>;
+}
+export declare namespace PageRepository {
+    type ConstructorArgs = {
+        sdk: EditorAppSDK;
+        contentfulClient: ContentfulContentClient;
+    };
+    namespace Load {
+        type Args = {
+            pageId?: Schema.Page.Id;
+        };
+        type Result = {
+            pageSummary: PageSummary;
+            page: Page;
+            sys: EntrySys;
+        };
+    }
+    namespace Sync {
+        type Args = {
+            page: Page;
+            sys: EntrySys;
+        };
+        type Result = {
+            pageSummary?: PageSummary;
+            page: Page;
+            sys: EntrySys;
+        };
+    }
+}