@nascentdigital/funnel-editor-contentful 4.6.7 → 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

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

package/dist/page/controller/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("./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,53 +1,90 @@
-import { AssetClient } from '@nascentdigital/funnel-cms';
-import { EventBus, Language, Schema } from '@nascentdigital/funnel-core';
+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';
 export declare class Page implements IPage {
     readonly id: Schema.Page.Id;
     readonly template: Schema.Page;
     readonly eventBus: EventBus;
+    readonly settings: PageSettings;
     readonly groupId: Schema.Page.GroupId;
     readonly brand: string;
     readonly language: Language;
     readonly region: string;
-    readonly url: string;
     readonly publishedOn?: number;
     readonly createdOn: number;
-    readonly updatedOn: number;
+    private _state;
+    private _initialErrors;
+    private readonly _discover;
     private readonly _content;
     private readonly _assets;
     private readonly _pages;
     private readonly _collections;
-    private readonly _tags;
     private _initialTags;
+    private readonly _tags;
+    private _initialName;
+    private _name;
     private _initialSlug;
+    private _url;
     private _slug;
-    private _syncing;
+    private _initialPublication?;
+    private _publication?;
+    private _updatedOn;
     private _modifiedOn?;
+    private _deletedBlocks;
+    private _syncing;
+    private readonly _subscription;
+    private _savingOn?;
+    readonly references: ReadonlyArray<ContentfulData.Link.Entry | ContentfulData.Link.Asset>;
     constructor(args: Page.ConstructorArgs);
-    settings: PageSettings;
-    publication: number | undefined;
     get events$(): Observable<IPage.Events>;
     get stable$(): Observable<boolean>;
+    get state(): Schema.Page.State;
+    private set state(value);
     get modified(): boolean;
+    get updatedOn(): number;
+    get changes(): Page.Changes;
     get published(): boolean;
+    get type(): Schema.Page.Type;
     get syncing(): boolean;
+    set syncing(syncing: boolean);
+    repair(): void;
+    get url(): string;
+    get initialSlug(): string | undefined;
     get hasSlug(): boolean;
+    set slug(slug: string | undefined);
     get slug(): string | undefined;
+    get initialName(): string;
+    get name(): string;
+    set name(name: string);
+    get initialPublication(): number | undefined;
+    get publication(): number | undefined;
+    set publication(publication: number | undefined);
+    get initialErrors(): boolean;
+    get errors(): Page.Errors;
+    get valid(): boolean;
+    get hasErrors(): boolean;
+    get asRef(): IPage.Ref;
     get discover(): ReadonlyArray<Block>;
+    get seo(): Block<Schema.Block<string, any, any>>;
+    getPreviewBlock(): Block | undefined;
     get content(): ReadonlyArray<Section | Block>;
     get blocks(): (Block<Schema.Block<string, any, any>> | SectionBlock<Schema.Block<string, any, any>>)[];
+    get deleteBlocks(): ReadonlyArray<Block>;
     get firstBlock(): Block<Schema.Block<string, any, any>> | SectionBlock<Schema.Block<string, any, any>> | undefined;
     get firstItem(): Block<Schema.Block<string, any, any>> | Section;
     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>;
+    hydrateStores(references: IPage.References): void;
     getItem(identifier: string | undefined): Block | SectionBlock | Section | PageSettings | undefined;
     coerceItem(identifier: string | undefined): Block | SectionBlock | Section | PageSettings;
-    deleteBlock(area: IPage.Area, key: string): void;
+    deleteBlock(area: IPage.Area, key: string): boolean;
     getAsset(assetId: Asset.Id): Asset | undefined;
     getAssetScope(range: Schema.AssetScope.Range): Schema.AssetScope;
     getSearchScope(): AssetClient.GetAssets.Scope;
@@ -61,8 +98,23 @@ export declare class Page implements IPage {
     removePageRef(pageId: Schema.Page.Id): boolean;
     addTag(tag: Schema.Tag): void;
     removeTag(tag: Schema.Tag): void;
+    onSaveStart(): void;
+    onSaveComplete(updatedOn: number): void;
+    private getBlock;
+    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;
@@ -75,15 +127,24 @@ export declare namespace Page {
         slug?: string;
         name: string;
         tags: Schema.Tag[];
+        discover: Blocks;
         content: Content;
         files?: Asset[];
         pages?: IPage.Ref[];
         collections?: Schema.Collection.Data.AsLink[];
         state: Schema.Page.State;
+        errors: boolean;
         createdOn: number;
         updatedOn: number;
         publishedOn?: number;
         publication?: number;
+        references: ContentfulData.References;
     };
-    type Content = Array<Block | Section>;
+    type FromSchemaData = {
+        data: ContentfulPageData.ForSchema;
+        references?: Schema.Page.References;
+        eventBus?: EventBus;
+    };
+    function fromSchemaData({ data, references, eventBus }: FromSchemaData): Page;
+    function toUpdates(page: Page, savables: IPage.Savable[]): PageClient.Update.Args;
 }