@nascentdigital/funnel-editor 4.4.18

package/dist/core/domain/Collections.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collections = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const CollectionBrowser_1 = require("./CollectionBrowser");
+// class
+class Collections {
+    constructor(args) {
+        // initialize instance variables
+        this.appState = args.appState;
+        this.editorApi = args.editorApi;
+        this.schemas = funnel_core_1.Schema.Site.current().collections;
+        this._eventBus = new funnel_core_1.EventBus();
+        this._state = 'uninitialized';
+        // start initial loading of data
+        this.sync().catch(console.error);
+        // listen to app state for page changes
+        this._subscription = this.appState.collectionEvents$.subscribe(e => this.onCollectionEvent(e));
+    }
+    get events$() {
+        return this._eventBus.events$;
+    }
+    get state() {
+        return this._state;
+    }
+    set state(state) {
+        // ignore if unchanged
+        if (this._state === state) {
+            return;
+        }
+        // update state
+        this._state = state;
+        // raise event
+        this.raiseEvent('changed');
+    }
+    get ready() {
+        return this._state === 'ready';
+    }
+    get items() {
+        var _a;
+        return (_a = this._collections) !== null && _a !== void 0 ? _a : [];
+    }
+    getItem(type) {
+        const { ready, items } = this;
+        return ready
+            ? items.find(item => item.type === type)
+            : undefined;
+    }
+    async sync() {
+        // return in-flight sync (if any)
+        if (this._syncPromise) {
+            return this._syncPromise;
+        }
+        // create sync
+        const onSync = async () => {
+            // get site map
+            try {
+                // mark as syncing
+                this.state = this._state === 'uninitialized'
+                    ? 'initializing'
+                    : 'syncing';
+                // load collections
+                const { editorApi } = this;
+                const overviews = await editorApi.getCollectionsOverview({ version: 'draft' });
+                this._collections = overviews.map(overview => new CollectionBrowser_1.CollectionBrowser({ editorApi, overview }));
+                // mark as ready
+                this.state = 'ready';
+            }
+            // TODO: handle error
+            catch (e) {
+                console.error('[Collections/sync] refresh failed', e);
+                // move to error state
+                this.state = 'error';
+            }
+            // clear sync when complete
+            finally {
+                delete this._syncPromise;
+            }
+        };
+        // start sync (and capture)
+        this._syncPromise = onSync();
+        // return sync
+        return this._syncPromise;
+    }
+    raiseEvent(type) {
+        this._eventBus.publish(Collections.Event.create({ type, collections: this }));
+    }
+    onCollectionEvent(e) {
+        console.debug('[Collection/onCollectionEvent] handling collection event', e);
+    }
+}
+exports.Collections = Collections;
+// extension
+(function (Collections) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'Collections';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return funnel_core_1.EventBus.createEvent(Object.assign({ domain: 'Collections' }, event));
+        }
+        Event.create = create;
+    })(Event = Collections.Event || (Collections.Event = {}));
+})(Collections || (exports.Collections = Collections = {}));

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

@@ -0,0 +1,15 @@
+import { AssetClient } from '@nascentdigital/funnel-cms';
+import { Schema } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { Asset } from './Asset';
+export interface IAssetStore {
+    readonly stable$: Observable<boolean>;
+    readonly syncing: boolean;
+    readonly modified: boolean;
+    readonly assets: ReadonlyArray<Asset>;
+    getAssetScope(range: Schema.AssetScope.Range): Schema.AssetScope;
+    getSearchScope(): AssetClient.GetAssets.Scope;
+    getAsset(assetId: Asset.Id): Asset | undefined;
+    addAsset(asset: Asset): void;
+    removeAsset(assetId: Asset.Id): boolean;
+}

package/dist/core/domain/IAssetStore.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,12 @@
+import { Language, Schema } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+export interface ICollectionStore {
+    readonly stable$: Observable<boolean>;
+    readonly syncing: boolean;
+    readonly modified: boolean;
+    readonly language: Language;
+    readonly collections: ReadonlyArray<Schema.Collection.Data.AsLink>;
+    getCollection(collectionId: Schema.Collection.Id): Schema.Collection.Data.AsLink | undefined;
+    addCollection(collection: Schema.Collection.Data.AsLink): void;
+    removeCollection(collectionId: Schema.Collection.Id): boolean;
+}

package/dist/core/domain/ICollectionStore.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,12 @@
+import { Language, Schema } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { Page } from './Page';
+export interface IPageRefStore {
+    readonly stable$: Observable<boolean>;
+    readonly syncing: boolean;
+    readonly modified: boolean;
+    readonly language: Language;
+    getPageRef(pageId: Schema.Page.Id): Page.Ref | undefined;
+    addPageRef(ref: Page.Ref): void;
+    removePageRef(pageId: Schema.Page.Id): boolean;
+}

package/dist/core/domain/IPageRefStore.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+import { Schema } from '@nascentdigital/funnel-core';
+export interface ITagged {
+    readonly tagGroups: ReadonlyArray<Schema.TagGroup>;
+    readonly initialTags: ReadonlySet<Schema.Tag>;
+    readonly tags: ReadonlySet<Schema.Tag>;
+    addTag(tag: Schema.Tag): void;
+    removeTag(tag: Schema.Tag): void;
+}

package/dist/core/domain/ITagged.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,18 @@
+import { EventBus } from '@nascentdigital/funnel-core';
+import { Tagged } from 'type-fest';
+import { Block } from './Block';
+import { Section } from './Section';
+import { SectionBlock } from './SectionBlock';
+export declare namespace Item {
+    type Key = Tagged<string, 'Item.Key'>;
+    type Type = Block | Section | SectionBlock;
+    type State = 'undefined' | 'invalid' | 'valid';
+    interface Event extends EventBus.Event<'Item', Event.Type> {
+        item: Type;
+    }
+    namespace Event {
+        type Type = 'changed';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}

package/dist/core/domain/Item.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Item = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// extension
+var Item;
+(function (Item) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'Item';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return funnel_core_1.EventBus.createEvent(Object.assign({ domain: 'Item' }, event));
+        }
+        Event.create = create;
+    })(Event = Item.Event || (Item.Event = {}));
+})(Item || (exports.Item = Item = {}));

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

@@ -0,0 +1,45 @@
+import { EventBus } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { Block, Item, Page, Section, SectionBlock } from './';
+export declare abstract class ItemBase<T extends Item.Type> {
+    readonly key: Item.Key;
+    private _required;
+    readonly eventBus: EventBus;
+    protected _isNew: boolean;
+    protected _activated: boolean;
+    private _parentContext?;
+    protected constructor(args: ItemBase.ConstructorArgs);
+    get events$(): Observable<Item.Event>;
+    get isNew(): boolean;
+    abstract get identifier(): string;
+    abstract get name(): string;
+    get required(): boolean;
+    get canDelete(): boolean;
+    abstract get state(): Item.State;
+    get activated(): boolean;
+    set activated(activated: boolean);
+    protected onActivate(): void;
+    abstract get modified(): boolean;
+    abstract get valid(): boolean;
+    get root(): Page;
+    private get parentContext();
+    get parent(): Section | Page;
+    get area(): Page.Area;
+    bind(parentContext: ItemBase.ParentContext): void;
+    getClosestBlock(direction?: 'prev' | 'next'): SectionBlock | Block | undefined;
+    delete(): undefined;
+    abstract repair(): void;
+    protected raiseEvent(type: Item.Event.Type): void;
+}
+export declare namespace ItemBase {
+    type ConstructorArgs = {
+        eventBus: EventBus;
+        key: string;
+        required: boolean;
+        exists: boolean;
+    };
+    type ParentContext = {
+        parent: Page | Section;
+        area: Page.Area;
+    };
+}

package/dist/core/domain/ItemBase.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemBase = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const rxjs_1 = require("rxjs");
+const _1 = require("./");
+// class
+class ItemBase {
+    constructor(args) {
+        // initialize instance variables
+        this.key = args.key;
+        this._required = args.required;
+        this.eventBus = args.eventBus;
+        this._isNew = !args.exists;
+        this._activated = args.exists;
+    }
+    get events$() {
+        return this.eventBus.events$.pipe((0, rxjs_1.filter)(_1.Item.Event.filter), (0, rxjs_1.filter)(e => e.item === this));
+    }
+    get isNew() {
+        return this._isNew;
+    }
+    get required() {
+        return this._required;
+    }
+    get canDelete() {
+        return !this._required || this.parent instanceof _1.Section;
+    }
+    get activated() {
+        return this._activated;
+    }
+    set activated(activated) {
+        // skip if unchanged
+        if (this._activated === activated) {
+            return;
+        }
+        // update
+        this._activated = activated;
+        this.onActivate();
+        // raise event
+        this.raiseEvent('changed');
+    }
+    onActivate() {
+    }
+    get root() {
+        // search for root page
+        let root = this.parent;
+        while (root instanceof _1.Section) {
+            root = root.parent;
+        }
+        // return it
+        return root;
+    }
+    get parentContext() {
+        // throw if not bound
+        const { _parentContext } = this;
+        if (!_parentContext) {
+            console.error('[ItemBase/parentContext] attempt to access unbound block/section', this);
+            throw new funnel_core_1.InvalidOperationError('Attempt to access unbound Block/Section');
+        }
+        // return parent
+        return _parentContext;
+    }
+    get parent() {
+        return this.parentContext.parent;
+    }
+    get area() {
+        return this.parentContext.area;
+    }
+    bind(parentContext) {
+        // throw if already bound
+        if (this._parentContext) {
+            throw new funnel_core_1.InvalidOperationError('Attempt to rebind Block/Section');
+        }
+        // bind
+        this._parentContext = parentContext;
+        // make required if parent is a section block
+        if (parentContext.parent instanceof _1.Section) {
+            this._required = true;
+        }
+    }
+    getClosestBlock(direction) {
+        // search for closest sibling
+        const { parentContext: { parent, area } } = this;
+        // search section (if it's the parent)
+        const parentTarget = parent instanceof _1.Section
+            ? parent
+            : this;
+        if (parent instanceof _1.Section && this instanceof _1.SectionBlock && parent.blocks.length > 1) {
+            // use prev block if it's not the first AND looking at prev
+            const parentBlocks = parent.blocks;
+            const blockIndex = parentBlocks.findIndex(block => block.id === this.id);
+            if ((!direction || direction === 'prev') && blockIndex > 0) {
+                return parentBlocks[blockIndex - 1];
+            }
+            // or use next block if it's not the last AND looking at next
+            else if ((!direction || direction === 'next') && blockIndex < parentBlocks.length - 1) {
+                return parentBlocks[blockIndex + 1];
+            }
+        }
+        // look at page (use sanity check)
+        const page = parent instanceof _1.Page
+            ? parent
+            : parent.parent;
+        if (!(page instanceof _1.Page)) {
+            throw new funnel_core_1.IllegalStateError('Expected parent to be Page');
+        }
+        // type guard
+        function isBlock(item) {
+            return item instanceof _1.Block;
+        }
+        // resolve self in page OR return first/last item depending on prev/next
+        const areaItems = page[area].slice();
+        const itemIndex = areaItems.indexOf(parentTarget);
+        if ((!direction || direction === 'prev') && itemIndex > 0) {
+            const blocks = areaItems.slice(0, itemIndex)
+                .filter(isBlock);
+            return funnel_core_1.ArrayUtils.last(blocks);
+        }
+        else if ((!direction || direction === 'next') && itemIndex < areaItems.length - 1) {
+            const blocks = areaItems.slice(itemIndex + 1)
+                .filter(isBlock);
+            return funnel_core_1.ArrayUtils.first(blocks);
+        }
+        else {
+            const blocks = areaItems.filter(isBlock);
+            return !direction || direction === 'prev'
+                ? funnel_core_1.ArrayUtils.first(blocks)
+                : funnel_core_1.ArrayUtils.last(blocks);
+        }
+    }
+    delete() {
+        // throw if required
+        const { canDelete, parentContext: { parent, area } } = this;
+        if (!canDelete) {
+            throw new funnel_core_1.InvalidOperationError('Cannot delete required Block');
+        }
+        // delete section block from section
+        else if (this instanceof _1.SectionBlock && parent instanceof _1.Section) {
+            parent.deleteBlock(this.id);
+        }
+        // or delete block from page
+        else if (this instanceof _1.Block && parent instanceof _1.Page) {
+            parent.deleteBlock(area, this.key);
+        }
+        // or do nothing
+        return undefined;
+    }
+    raiseEvent(type) {
+        this.eventBus.publish(_1.Item.Event.create({ type, item: this }));
+    }
+}
+exports.ItemBase = ItemBase;

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

@@ -0,0 +1,172 @@
+import { AssetClient } from '@nascentdigital/funnel-cms';
+import { EventBus, Field, FieldList, FieldModel, Language, ObjectField, Schema } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { Asset, Block, IAssetStore, ICollectionStore, IPageRefStore, ITagged, Item, PageSummary, Section, SectionBlock } from './';
+import { PageSettings } from './PageSettings';
+export declare class Page implements IAssetStore, ICollectionStore, IPageRefStore, ITagged {
+    readonly template: Schema.Page;
+    readonly eventBus: EventBus;
+    readonly settings: PageSettings;
+    readonly id: Schema.Page.Id;
+    readonly groupId: Schema.Page.GroupId;
+    readonly brand: string;
+    readonly language: Language;
+    readonly region: string;
+    readonly route: Schema.PageRoute;
+    private _url;
+    private _initialSlug;
+    private _slug;
+    private _initialName;
+    private _name;
+    private _initialTags;
+    private readonly _tags;
+    private readonly _discover;
+    private readonly _content;
+    private readonly _assets;
+    private readonly _pages;
+    private readonly _collections;
+    private _state;
+    private _initialErrors;
+    private _changeSetId?;
+    readonly snapshotId?: Schema.PageSnapshot.Id;
+    readonly snapshot?: Schema.PageSnapshot;
+    readonly createdOn: number;
+    private _updatedOn;
+    readonly publishedOn?: number;
+    private _initialPublication?;
+    private _publication?;
+    private readonly _subscription;
+    private _deletedBlocks;
+    private _syncing;
+    private _modifiedOn?;
+    private _savingOn?;
+    constructor(args: Page.ConstructorArgs);
+    get events$(): Observable<Page.Events>;
+    get stable$(): Observable<boolean>;
+    get state(): Schema.Page.State;
+    private set state(value);
+    get syncing(): boolean;
+    set syncing(syncing: boolean);
+    get type(): Schema.Page.Type;
+    get assets(): ReadonlyArray<Asset>;
+    get collections(): ReadonlyArray<Schema.Collection.Data.AsLink>;
+    get url(): string;
+    get hasSlug(): boolean;
+    get initialSlug(): string | undefined;
+    get slug(): string | undefined;
+    set slug(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 initialTags(): ReadonlySet<Schema.Tag<string, string>>;
+    get tagGroups(): ReadonlyArray<Schema.TagGroup>;
+    get tags(): ReadonlySet<Schema.Tag>;
+    addTag(tag: Schema.Tag): void;
+    removeTag(tag: Schema.Tag): void;
+    get displayName(): string | Schema.Field.Data.ForSimpleType<Schema.TextField>;
+    get discover(): ReadonlyArray<Block>;
+    get content(): ReadonlyArray<Section | Block>;
+    get seo(): Block<Schema.Block<string, any, any>>;
+    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(): Section | Block<Schema.Block<string, any, any>>;
+    get published(): boolean;
+    get modified(): boolean;
+    get updatedOn(): number;
+    get changeSetId(): Schema.ChangeSet.Id | undefined;
+    get valid(): boolean;
+    get items(): Array<Block | Section>;
+    get changes(): Page.Changes;
+    get initialErrors(): boolean;
+    get errors(): Page.Errors;
+    get hasErrors(): boolean;
+    get asRef(): Page.Ref;
+    /**
+     * Synchronizes computed properties with the latest data (e.g. updating `url` from route template or name)
+     */
+    sync(): void;
+    getItem(identifier: string | undefined): Block | SectionBlock | Section | PageSettings | undefined;
+    getPreviewBlock(): Block | undefined;
+    coerceItem(identifier: string | undefined): Block | SectionBlock | Section | PageSettings;
+    deleteBlock(area: Page.Area, key: string): boolean;
+    getAssetScope(range: Schema.AssetScope.Range): Schema.AssetScope;
+    getSearchScope(): AssetClient.GetAssets.Scope;
+    getAsset(assetId: Asset.Id): Asset | undefined;
+    addAsset(asset: Asset): void;
+    removeAsset(assetId: Asset.Id): boolean;
+    getCollection(collectionId: Schema.Collection.Id): Schema.Collection.Data.AsLink | undefined;
+    addCollection(collection: Schema.Collection.Data.AsLink): void;
+    removeCollection(collectionId: Schema.Collection.Id): boolean;
+    getPageRef(pageId: Schema.Page.Id | undefined): Page.Ref | undefined;
+    addPageRef(page: Page.Ref): void;
+    removePageRef(pageId: string): boolean;
+    repair(): void;
+    onSaveStart(): void;
+    onSaveComplete(updatedOn: number, changeSetId: Schema.ChangeSet.Id): void;
+    private computeName;
+    private computeUrl;
+    private getValue;
+    private getBlock;
+    private raiseEvent;
+}
+export declare namespace Page {
+    type ConstructorArgs = {
+        template: Schema.Page;
+        eventBus: EventBus;
+        id: Schema.Page.Id;
+        groupId: Schema.Page.GroupId;
+        brand: string;
+        language: Language;
+        region: string;
+        url: string;
+        slug?: string;
+        name: string;
+        tags: Schema.Tag[];
+        discover: Blocks;
+        content: Content;
+        files?: Asset[];
+        pages?: Ref[];
+        collections?: Schema.Collection.Data.AsLink[];
+        state: Schema.Page.State;
+        errors: boolean;
+        changeSetId?: Schema.ChangeSet.Id;
+        snapshotId?: Schema.PageSnapshot.Id;
+        snapshot?: Schema.PageSnapshot;
+        createdOn: number;
+        updatedOn: number;
+        publishedOn?: number;
+        publication?: number;
+    };
+    type Blocks = Block[];
+    type Content = Array<Block | Section>;
+    type Changes = {
+        page: Page;
+        items: Array<Block | Section>;
+    };
+    type Errors = {
+        page: Page;
+        items: Array<Block | Section>;
+    };
+    type WithSummary = {
+        summary: PageSummary;
+        page?: Page;
+    };
+    type Area = 'discover' | 'content';
+    type Target = Block | SectionBlock | Section | FieldModel;
+    type Ref = Pick<ConstructorArgs, 'id' | 'groupId' | 'brand' | 'template' | 'region' | 'language' | 'url' | 'slug' | 'tags' | 'createdOn' | 'updatedOn' | 'publishedOn'> & {
+        name: string;
+    };
+    type Events = Event | Item.Event | Field.Event | ObjectField.Event | FieldList.Event;
+    interface Event extends EventBus.Event<'Page', Event.Type> {
+        page: Page;
+    }
+    namespace Event {
+        type Type = 'changed' | 'modified';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}