@nascentdigital/funnel-editor-contentful 4.6.7 → 5.0.2

package/dist/page/domain/Page.js

@@ -0,0 +1,631 @@
+"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");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const rxjs_1 = require("rxjs");
+// class
+class Page {
+    constructor(args) {
+        var _a, _b, _c;
+        // initialize instance variables
+        this.id = args.id;
+        this.template = args.template;
+        this.eventBus = args.eventBus;
+        this.groupId = args.groupId;
+        this.brand = args.brand;
+        this.language = args.language;
+        this.region = args.region;
+        this.publishedOn = args.publishedOn;
+        this.createdOn = args.createdOn;
+        this.settings = new components_1.PageSettings(this);
+        this._state = args.state;
+        this._initialErrors = args.errors;
+        this._initialName = this._name = args.name;
+        this._updatedOn = args.updatedOn;
+        this._discover = args.discover;
+        this._content = args.content;
+        this._url = args.url;
+        this._initialSlug = this._slug = args.slug;
+        this._initialPublication = this._publication = args.publication;
+        this._assets = (_a = args.files) !== null && _a !== void 0 ? _a : [];
+        this._pages = (_b = args.pages) !== null && _b !== void 0 ? _b : [];
+        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
+        this._discover.forEach(item => item.bind({ parent: this, area: 'discover' }));
+        this._content.forEach((item) => item.bind({ parent: this, area: 'content' }));
+        // listen to block/field changes
+        this._subscription = this.eventBus.events$
+            .pipe((0, rxjs_1.filter)(e => (funnel_core_1.Field.Event.filter(e) && e.type === 'changed' && !e.field.sandboxed)
+            || (funnel_core_1.FieldList.Event.filter(e) && e.type === 'changed')
+            || (funnel_core_1.ObjectField.Event.filter(e) && e.type === 'changed')
+            || (components_1.Item.Event.filter(e) && e.type === 'changed')))
+            .subscribe(() => this.raiseEvent('changed'));
+    }
+    get events$() {
+        return this.eventBus.events$;
+    }
+    get stable$() {
+        return this.eventBus.events$.pipe((0, rxjs_1.map)(() => !this._syncing && !this.modified), (0, rxjs_1.distinctUntilChanged)());
+    }
+    get state() {
+        return this._state;
+    }
+    set state(state) {
+        // skip if unchanged
+        if (this._state === state) {
+            return;
+        }
+        // update state
+        this._state = state;
+        this._modifiedOn = Date.now();
+        // raise change
+        this.raiseEvent('changed');
+    }
+    get modified() {
+        const { _deletedBlocks, initialSlug, _slug, initialPublication, _publication, initialTags, _tags, items } = this;
+        return _deletedBlocks.length > 0
+            || initialSlug !== _slug
+            || initialPublication !== _publication
+            || initialTags.symmetricDifference(_tags).size > 0
+            || items.some(item => item.modified);
+    }
+    get updatedOn() {
+        return this._updatedOn;
+    }
+    get changes() {
+        return {
+            page: this,
+            items: this.items.filter(item => item instanceof components_1.Section
+                ? item.changes.blocks.length > 0
+                : item.changes.fields.length > 0)
+        };
+    }
+    get published() {
+        return this.publishedOn !== undefined;
+    }
+    get type() {
+        return this.template.type;
+    }
+    get syncing() {
+        return this._syncing;
+    }
+    set syncing(syncing) {
+        this._syncing = syncing;
+        this.raiseEvent('changed');
+    }
+    repair() {
+        // repair all content blocks
+        this.blocks.forEach(block => block.repair());
+    }
+    get url() {
+        return this._url;
+    }
+    get initialSlug() {
+        return this._initialSlug;
+    }
+    get hasSlug() {
+        return this.template.variant === 'dynamic';
+    }
+    set slug(slug) {
+        // stop static pages from setting slugs
+        if (!this.hasSlug) {
+            throw new funnel_core_1.InvalidOperationError('Cannot set slug on static page');
+        }
+        // or from being unset
+        else if (!slug) {
+            throw new funnel_core_1.ArgumentError('Slug cannot be unset');
+        }
+        // ignore if unchanged
+        else if (this._slug === slug) {
+            return;
+        }
+        // update slug
+        this._slug = slug;
+        this._modifiedOn = Date.now();
+        // raise change
+        this.raiseEvent('modified');
+    }
+    get slug() {
+        return this._slug;
+    }
+    get initialName() {
+        return this._initialName;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(name) {
+        // ignore if unchanged
+        if (this._name === name) {
+            return;
+        }
+        // update name
+        this._name = name;
+        this._modifiedOn = Date.now();
+        // raise change
+        this.raiseEvent('modified');
+    }
+    get initialPublication() {
+        return this._initialPublication;
+    }
+    get publication() {
+        return this._publication;
+    }
+    set publication(publication) {
+        // ignore if unchanged
+        if (this._publication === publication) {
+            return;
+        }
+        // update name
+        this._publication = publication;
+        this._modifiedOn = Date.now();
+        // raise change
+        this.raiseEvent('modified');
+    }
+    get initialErrors() {
+        return this._initialErrors;
+    }
+    get errors() {
+        return {
+            page: this,
+            items: this.items.filter(item => (!item.activated && item.required)
+                || (item.activated && !item.valid))
+        };
+    }
+    get valid() {
+        return this.errors.items.length === 0;
+    }
+    get hasErrors() {
+        return this.errors.items.length > 0;
+    }
+    get asRef() {
+        const { id, groupId, template, brand, region, language, slug, url, name, tags, state, hasErrors, createdOn, updatedOn, publishedOn } = this;
+        return {
+            id, groupId, template,
+            brand, region, language, slug, url, name, tags: Array.from(tags),
+            state, errors: hasErrors, createdOn, updatedOn, publishedOn
+        };
+    }
+    get discover() {
+        return this._discover;
+    }
+    get seo() {
+        // get seo (or blow up)
+        const seo = this.discover.find(block => block.key === 'seo');
+        if (!seo) {
+            throw new funnel_core_1.IllegalStateError('Failed to resolve SEO block - should always exist');
+        }
+        // return seo
+        return seo;
+    }
+    getPreviewBlock() {
+        // get preview block identifier
+        const previewBlockIdentifier = this.template.preview;
+        // bail if no identifier specified
+        if (!previewBlockIdentifier) {
+            return undefined;
+        }
+        // otherwise try to get the preview block
+        return this.getBlock(previewBlockIdentifier);
+    }
+    get content() {
+        return this._content;
+    }
+    get blocks() {
+        return this.content
+            .flatMap((item) => item instanceof components_1.Section ? item.blocks : item);
+    }
+    get deleteBlocks() {
+        return this._deletedBlocks;
+    }
+    get firstBlock() {
+        // find first block
+        for (const item of this.content) {
+            // return item if it matches
+            if (item instanceof components_1.Block) {
+                return item;
+            }
+            // search deeply into sections
+            else {
+                const { blocks } = item;
+                if (blocks.length > 0) {
+                    return blocks[0];
+                }
+            }
+        }
+        // or return undefined
+        return undefined;
+    }
+    get firstItem() {
+        return this.content[0];
+    }
+    get items() {
+        return [...this._discover, ...this._content];
+    }
+    get assets() {
+        return this._assets;
+    }
+    get collections() {
+        return this._collections;
+    }
+    get pages() {
+        return this._pages;
+    }
+    get initialTags() {
+        return this._initialTags;
+    }
+    get tagGroups() {
+        return this.template.tags;
+    }
+    get tags() {
+        return this._tags;
+    }
+    hydrateStores(references) {
+        this._assets.push(...references.assets);
+        this._pages.push(...references.pages);
+        this._collections.push(...references.collections);
+    }
+    getItem(identifier) {
+        // skip if there's no identifier
+        if (!identifier) {
+            return undefined;
+        }
+        // or return settings
+        else if (identifier === components_1.PageSettings.id) {
+            return this.settings;
+        }
+        // search content for item
+        for (const item of this.items) {
+            // return item if it matches
+            if (item.identifier === identifier) {
+                return item;
+            }
+            // search deeply into sections
+            if (item instanceof components_1.Section) {
+                for (const block of item.blocks) {
+                    // return block if it matches
+                    if (block.identifier === identifier) {
+                        return block;
+                    }
+                }
+            }
+        }
+        // or return undefined
+        return undefined;
+    }
+    coerceItem(identifier) {
+        var _a, _b;
+        return (_b = (_a = this.getItem(identifier)) !== null && _a !== void 0 ? _a : this.firstBlock) !== null && _b !== void 0 ? _b : this.firstItem;
+    }
+    deleteBlock(area, key) {
+        // get parent
+        let parent;
+        switch (area) {
+            case 'discover':
+                parent = this._discover;
+                break;
+            case 'content':
+                parent = this._content;
+                break;
+        }
+        // skip if item isn't in parent
+        const blockIndex = parent.findIndex(item => item.key === key);
+        if (!blockIndex) {
+            return false;
+        }
+        // remove item
+        const [deletedBlock] = parent.splice(blockIndex, 1);
+        this._modifiedOn = Date.now();
+        // track deletion of top-level blocks
+        if (deletedBlock instanceof components_1.Block) {
+            console.debug('Removing deleted block', deletedBlock);
+            this._deletedBlocks.push(deletedBlock);
+        }
+        // raise change
+        this.raiseEvent('modified');
+        // indicate success
+        return true;
+    }
+    getAsset(assetId) {
+        return this._assets.find((asset) => asset.value.id === assetId);
+    }
+    getAssetScope(range) {
+        switch (range) {
+            case 'global':
+                return funnel_core_1.Schema.AssetScope.global;
+            case 'type':
+                return new funnel_core_1.Schema.PageTypeAssetScope(this.type);
+            case 'instance':
+                return new funnel_core_1.Schema.PageInstanceAssetScope(this.groupId);
+        }
+    }
+    getSearchScope() {
+        return {
+            target: 'page',
+            type: this.type,
+            groupId: this.groupId
+        };
+    }
+    addAsset(asset) {
+        // replace asset if it exists
+        const { _assets } = this;
+        const { id } = asset.value;
+        const assetIndex = _assets.findIndex(asset => asset.value.id === id);
+        if (assetIndex >= 0) {
+            _assets[assetIndex] = asset;
+        }
+        // or add asset
+        else {
+            _assets.push(asset);
+        }
+        // raise event
+        this.raiseEvent('changed');
+    }
+    removeAsset(assetId) {
+        // skip if asset isn't there
+        const { _assets } = this;
+        const assetIndex = _assets.findIndex(asset => asset.value.id === assetId);
+        if (assetIndex < 0) {
+            return false;
+        }
+        // remove asset
+        _assets.splice(assetIndex, 1);
+        // raise event
+        this.raiseEvent('changed');
+        // indicate success
+        return true;
+    }
+    getCollection(collectionId) {
+        return this._collections.find(collection => collection.id === collectionId);
+    }
+    addCollection(collection) {
+        // replace collection if it exists
+        const { _collections } = this;
+        const collectionId = collection.id;
+        const collectionIndex = _collections.findIndex(collection => collection.id === collectionId);
+        if (collectionIndex >= 0) {
+            _collections[collectionIndex] = collection;
+        }
+        // or add collection
+        else {
+            _collections.push(collection);
+        }
+        // raise event
+        this.raiseEvent('changed');
+    }
+    removeCollection(collectionId) {
+        // skip if collection isn't there
+        const { _collections } = this;
+        const collectionIndex = _collections.findIndex(collection => collection.id === collectionId);
+        if (collectionIndex < 0) {
+            return false;
+        }
+        // remove collection
+        const [collection] = _collections.splice(collectionIndex, 1);
+        // raise event
+        this.raiseEvent('changed');
+        // indicate success
+        return true;
+    }
+    getPageRef(pageId) {
+        return pageId && pageId !== funnel_core_1.Schema.Page.Id.draft
+            ? this._pages.find((ref) => ref.id === pageId)
+            : undefined;
+    }
+    addPageRef(ref) {
+        // throw if page is a draft
+        if (ref.id === funnel_core_1.Schema.Page.Id.draft) {
+            throw new funnel_core_1.InvalidOperationError('Cannot add draft Page as reference');
+        }
+        // replace ref if it exists
+        const { _pages } = this;
+        const pageId = ref.id;
+        const refIndex = _pages.findIndex(ref => ref.id === pageId);
+        if (refIndex >= 0) {
+            _pages[refIndex] = ref;
+        }
+        // or add ref
+        else {
+            _pages.push(ref);
+        }
+        // raise event
+        this.raiseEvent('changed');
+    }
+    removePageRef(pageId) {
+        // skip if file isn't there
+        const { _pages } = this;
+        const refIndex = _pages.findIndex(ref => ref.id === pageId);
+        if (refIndex < 0) {
+            return false;
+        }
+        // remove file
+        _pages.splice(refIndex, 1);
+        // raise event
+        this.raiseEvent('changed');
+        // indicate success
+        return true;
+    }
+    addTag(tag) {
+        throw new Error('Method not implemented.');
+    }
+    removeTag(tag) {
+        throw new Error('Method not implemented.');
+    }
+    onSaveStart() {
+        this._savingOn = Date.now();
+    }
+    onSaveComplete(updatedOn) {
+        // update fundamentals
+        this._updatedOn = updatedOn;
+        this._state = 'draft';
+        // reset to values to match save
+        const { _modifiedOn, _savingOn } = this;
+        if (_savingOn && (!_modifiedOn || _savingOn >= _modifiedOn)) {
+            // sync data
+            this._initialErrors = !this.valid;
+            this._initialSlug = this._slug;
+            this._initialName = this._name;
+            this._initialTags = new Set(this._tags);
+            this._initialPublication = this._publication;
+            this._deletedBlocks = [];
+        }
+        // clear saving flag
+        delete this._savingOn;
+    }
+    getBlock(identifier) {
+        // try to find item
+        const item = this.getItem(identifier);
+        // make sure it is a block
+        if (item instanceof components_1.Block) {
+            return item;
+        }
+        // otherwise undefined
+        else {
+            return undefined;
+        }
+    }
+    raiseEvent(type) {
+        this.eventBus.publish(components_1.IPage.Event.create({ type, page: this }));
+    }
+}
+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/index.d.ts

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

package/dist/page/index.js

@@ -14,4 +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;
+        };
+    }
+}