@nascentdigital/funnel-editor-contentful 4.6.7 → 5.0.1

package/dist/core/domain/Page.d.ts

@@ -1,42 +1,75 @@
 import { AssetClient } from '@nascentdigital/funnel-cms';
-import { EventBus, Language, Schema } from '@nascentdigital/funnel-core';
+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?;
     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>;
@@ -45,9 +78,10 @@ export declare class Page implements IPage {
     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,6 +95,10 @@ 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 ConstructorArgs = {
@@ -75,15 +113,27 @@ 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;
     };
+    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;
 }

package/dist/core/domain/Page.js

@@ -16,21 +16,35 @@ class Page {
         this.brand = args.brand;
         this.language = args.language;
         this.region = args.region;
-        this.url = args.url;
         this.publishedOn = args.publishedOn;
         this.createdOn = args.createdOn;
-        this.updatedOn = args.updatedOn;
         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._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$;
@@ -38,23 +52,166 @@ class Page {
     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() {
-        return false;
+        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 [];
+        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;
@@ -63,6 +220,9 @@ class Page {
         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) {
@@ -85,7 +245,7 @@ class Page {
         return this.content[0];
     }
     get items() {
-        return [...this._content];
+        return [...this._discover, ...this._content];
     }
     get assets() {
         return this._assets;
@@ -102,6 +262,11 @@ class Page {
     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) {
@@ -135,40 +300,152 @@ class Page {
         return (_b = (_a = this.getItem(identifier)) !== null && _a !== void 0 ? _a : this.firstBlock) !== null && _b !== void 0 ? _b : this.firstItem;
     }
     deleteBlock(area, key) {
-        throw new Error('Method not implemented.');
+        // 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) {
-        throw new Error('Method not implemented.');
+        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() {
-        throw new Error('Method not implemented.');
+        return {
+            target: 'page',
+            type: this.type,
+            groupId: this.groupId
+        };
     }
     addAsset(asset) {
-        throw new Error('Method not implemented.');
+        // 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) {
-        throw new Error('Method not implemented.');
+        // 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) {
-        throw new Error('Method not implemented.');
+        return this._collections.find(collection => collection.id === collectionId);
     }
     addCollection(collection) {
-        throw new Error('Method not implemented.');
+        // 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) {
-        throw new Error('Method not implemented.');
+        // 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;
+        return pageId && pageId !== funnel_core_1.Schema.Page.Id.draft
+            ? this._pages.find((ref) => ref.id === pageId)
+            : undefined;
     }
     addPageRef(ref) {
-        throw new Error('Method not implemented.');
+        // 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) {
-        throw new Error('Method not implemented.');
+        // 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.');
@@ -176,5 +453,41 @@ class Page {
     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;

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

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

package/dist/core/domain/index.js

@@ -14,4 +14,5 @@ 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("./Collection"), exports);
 __exportStar(require("./Page"), exports);

package/dist/core/index.d.ts

@@ -1,3 +1,5 @@
 export * from './api';
+export * from './bridge';
+export * from './contentful';
 export * from './domain';
 export * from './repository';

package/dist/core/index.js

@@ -15,5 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./api"), exports);
+__exportStar(require("./bridge"), exports);
+__exportStar(require("./contentful"), exports);
 __exportStar(require("./domain"), exports);
 __exportStar(require("./repository"), exports);

package/dist/core/repository/AssetRepository.d.ts

@@ -0,0 +1,10 @@
+import { EditorAppSDK } from '@contentful/app-sdk';
+import { IAssetRepository } from '@nascentdigital/funnel-editor/components';
+export declare class AssetRepository implements IAssetRepository {
+    readonly sdk: EditorAppSDK;
+    constructor(sdk: EditorAppSDK);
+    search(args: IAssetRepository.Search.Args): Promise<IAssetRepository.Search.Result>;
+    get(args: IAssetRepository.Get.Args): Promise<IAssetRepository.Get.Result>;
+    update(args: IAssetRepository.Update.Args): Promise<IAssetRepository.Update.Result>;
+    uploadFile(args: IAssetRepository.UploadFile.Args): Promise<IAssetRepository.UploadFile.Result>;
+}

package/dist/core/repository/AssetRepository.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetRepository = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const contentful_1 = require("../contentful");
+// class
+class AssetRepository {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async search(args) {
+        // TODO: implement fetching assets
+        return {
+            items: [],
+            page: 1,
+            pageCount: 0,
+            totalItemCount: 0
+        };
+    }
+    async get(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async update(args) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async uploadFile(args) {
+        // upload asset
+        const asset = await contentful_1.ContentfulAsset.upload(args, this.sdk);
+        // return result
+        return contentful_1.ContentfulAsset.serialize(asset, this.sdk.locales.default);
+    }
+}
+exports.AssetRepository = AssetRepository;

package/dist/core/repository/CollectionSerializer.d.ts

@@ -0,0 +1,9 @@
+import { EventBus, Schema } from '@nascentdigital/funnel-core';
+import { Collection } from '../domain';
+export declare namespace CollectionSerializer {
+    type DeserializeCollectionArgs = {
+        flattenedCollection: Schema.Collection.FlattenedData;
+        eventBus: EventBus;
+    };
+    function deserializeCollection({ flattenedCollection, eventBus }: DeserializeCollectionArgs): Collection;
+}