@nascentdigital/funnel-editor 4.4.18

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

@@ -0,0 +1,38 @@
+import { Language, Schema } from '@nascentdigital/funnel-core';
+import { Page } from './Page';
+export type PageOverview = StaticPageOverview | DynamicPageOverview;
+export declare abstract class PageOverviewBase {
+    readonly template: Schema.Page;
+    readonly type: Schema.Page.Type;
+    protected constructor(args: PageOverviewBase.ConstructorArgs);
+    abstract get isEmpty(): boolean;
+}
+export declare namespace PageOverviewBase {
+    type ConstructorArgs = {
+        template: Schema.Page;
+        type: Schema.Page.Type;
+    };
+}
+export declare class StaticPageOverview extends PageOverviewBase {
+    readonly refs: Readonly<Record<Language, Schema.Page.Data.AsLink>>;
+    readonly languages: ReadonlyArray<Language>;
+    constructor({ refs, ...args }: StaticPageOverview.ConstructorArgs);
+    get isEmpty(): boolean;
+    hasLanguage(language: Language): boolean;
+    getClosestPageRef(language: Language, fallback?: Language): Page.Ref | undefined;
+}
+export declare namespace StaticPageOverview {
+    type ConstructorArgs = Omit<PageOverviewBase.ConstructorArgs, 'variant'> & {
+        refs: Record<Language, Schema.Page.Data.AsLink>;
+    };
+}
+export declare class DynamicPageOverview extends PageOverviewBase {
+    readonly count: number;
+    constructor({ count, ...args }: DynamicPageOverview.ConstructorArgs);
+    get isEmpty(): boolean;
+}
+export declare namespace DynamicPageOverview {
+    type ConstructorArgs = Omit<PageOverviewBase.ConstructorArgs, 'variant'> & {
+        count: number;
+    };
+}

package/dist/core/domain/PageOverview.js

@@ -0,0 +1,63 @@
+"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.DynamicPageOverview = exports.StaticPageOverview = exports.PageOverviewBase = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// model
+class PageOverviewBase {
+    constructor(args) {
+        // initialize instance variables
+        this.template = args.template;
+        this.type = args.type;
+    }
+}
+exports.PageOverviewBase = PageOverviewBase;
+// static
+class StaticPageOverview extends PageOverviewBase {
+    constructor(_a) {
+        var { refs } = _a, args = __rest(_a, ["refs"]);
+        // construct base
+        super(args);
+        // initialize instance variables
+        this.refs = refs;
+        this.languages = Object.keys(refs).map(funnel_core_1.Language.parse);
+    }
+    get isEmpty() {
+        return this.languages.length === 0;
+    }
+    hasLanguage(language) {
+        return this.languages.includes(language);
+    }
+    getClosestPageRef(language, fallback) {
+        var _a, _b;
+        const { template, languages, refs } = this;
+        const [firstLanguage] = languages;
+        const ref = (_b = (_a = refs[language]) !== null && _a !== void 0 ? _a : (fallback && refs[fallback])) !== null && _b !== void 0 ? _b : (firstLanguage && refs[firstLanguage]);
+        return ref && Object.assign(Object.assign({}, ref), { template, tags: template.tags.flatMap(tagGroup => tagGroup.parse(ref.tags)) });
+    }
+}
+exports.StaticPageOverview = StaticPageOverview;
+// dynamic
+class DynamicPageOverview extends PageOverviewBase {
+    constructor(_a) {
+        var { count } = _a, args = __rest(_a, ["count"]);
+        // construct base
+        super(args);
+        // initialize instance variables
+        this.count = count;
+    }
+    get isEmpty() {
+        return this.count === 0;
+    }
+}
+exports.DynamicPageOverview = DynamicPageOverview;

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

@@ -0,0 +1,31 @@
+import { Language, Schema } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { EditorApiClient } from '../client';
+import { IPageRefStore } from './IPageRefStore';
+import { Page } from './Page';
+export declare class PageRefStoreProxy implements IPageRefStore {
+    readonly language: Language;
+    private _parentStore;
+    private readonly _pages;
+    private readonly _pageIds;
+    private readonly _syncing$;
+    private readonly _editorApi;
+    constructor(args: PageRefStoreProxy.ConstructorArgs);
+    get syncing(): boolean;
+    get stable$(): Observable<boolean>;
+    get modified(): boolean;
+    bindParent(parent: IPageRefStore): PageRefStoreProxy;
+    load(pageIds?: Schema.Page.Id[]): Promise<void>;
+    getPageRef(pageId: Schema.Page.Id | undefined): Page.Ref | undefined;
+    addPageRef(page: Page.Ref): void;
+    removePageRef(pageId: Schema.Page.Id): boolean;
+}
+export declare namespace PageRefStoreProxy {
+    type ConstructorArgs = {
+        editorApi: EditorApiClient;
+        parent?: IPageRefStore;
+        language: Language;
+        pages?: ReadonlyArray<Page.Ref>;
+        pageIds?: ReadonlyArray<Schema.Page.Id>;
+    };
+}

package/dist/core/domain/PageRefStoreProxy.js

@@ -0,0 +1,118 @@
+"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.PageRefStoreProxy = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const rxjs_1 = require("rxjs");
+// class
+class PageRefStoreProxy {
+    constructor(args) {
+        var _a;
+        this.language = args.language;
+        this._parentStore = args.parent;
+        this._editorApi = args.editorApi;
+        this._pages = [...(_a = args.pages) !== null && _a !== void 0 ? _a : []];
+        this._pageIds = new Set(args.pageIds);
+        this._syncing$ = new rxjs_1.BehaviorSubject(true);
+    }
+    get syncing() {
+        return this._syncing$.getValue();
+    }
+    get stable$() {
+        return this._syncing$.asObservable();
+    }
+    get modified() {
+        return false;
+    }
+    bindParent(parent) {
+        this._parentStore = parent;
+        return this;
+    }
+    async load(pageIds) {
+        // merge in potentially new ids
+        pageIds === null || pageIds === void 0 ? void 0 : pageIds.forEach(id => this._pageIds.add(id));
+        // get ids with no references
+        const missingIds = Array.from(this._pageIds).filter(id => !this.getPageRef(id));
+        // bail if no loading needed
+        if (missingIds.length === 0) {
+            this._syncing$.next(false);
+            return;
+        }
+        // fetch missing page refs
+        const pageLinks = await this._editorApi.getPageSummaries({ ids: missingIds, version: 'draft' });
+        const pageRefs = pageLinks.map((_a) => {
+            var { tags } = _a, page = __rest(_a, ["tags"]);
+            // get page template/schema
+            const template = funnel_core_1.Schema.Site.getPage(page.type, page.region);
+            // return page ref
+            return Object.assign(Object.assign({ template }, page), { tags: template.tags.flatMap(tagGroup => tagGroup.parse(tags)) });
+        });
+        // add to store
+        this._pages.push(...pageRefs);
+        // signal syncing is finished
+        this._syncing$.next(false);
+    }
+    getPageRef(pageId) {
+        var _a;
+        // return undefined id not valid
+        if (pageId === undefined || pageId === funnel_core_1.Schema.Page.Id.draft) {
+            return undefined;
+        }
+        // first try looking in current store
+        const pageRef = this._pages.find(ref => ref.id === pageId);
+        if (pageRef) {
+            return pageRef;
+        }
+        // otherwise look in parent store
+        return (_a = this._parentStore) === null || _a === void 0 ? void 0 : _a.getPageRef(pageId);
+    }
+    addPageRef(page) {
+        // throw if page is a draft
+        if (page.id === funnel_core_1.Schema.Page.Id.draft) {
+            throw new funnel_core_1.InvalidOperationError('Cannot add draft Page as reference');
+        }
+        // try to add in parent store (store ref as high up as possible)
+        // if (this._parentStore) {
+        //   this._parentStore.addPageRef(page)
+        //   return
+        // }
+        // replace ref if it exists
+        const { _pages } = this;
+        const pageId = page.id;
+        const refIndex = _pages.findIndex(ref => ref.id === pageId);
+        if (refIndex >= 0) {
+            _pages[refIndex] = page;
+        }
+        // or add ref
+        else {
+            _pages.push(page);
+        }
+    }
+    removePageRef(pageId) {
+        // try to remove from parent first
+        // if (this._parentStore?.removePageRef(pageId)) {
+        //   return true
+        // }
+        // 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);
+        // indicate success
+        return true;
+    }
+}
+exports.PageRefStoreProxy = PageRefStoreProxy;

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

@@ -0,0 +1,11 @@
+import { Page } from './Page';
+export declare class PageSettings {
+    readonly page: Page;
+    readonly id = "__settings";
+    readonly name = "Settings";
+    constructor(page: Page);
+    get identifier(): string;
+}
+export declare namespace PageSettings {
+    const id = "__settings";
+}

package/dist/core/domain/PageSettings.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageSettings = void 0;
+// class
+class PageSettings {
+    constructor(page) {
+        this.page = page;
+        this.id = PageSettings.id;
+        this.name = 'Settings';
+    }
+    get identifier() {
+        return this.id;
+    }
+}
+exports.PageSettings = PageSettings;
+// extension
+(function (PageSettings) {
+    // constants
+    PageSettings.id = '__settings';
+})(PageSettings || (exports.PageSettings = PageSettings = {}));

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

@@ -0,0 +1,35 @@
+import { Language, Schema } from '@nascentdigital/funnel-core';
+import { Page } from './Page';
+export declare class PageSummary {
+    readonly template: Schema.Page;
+    readonly brand: string;
+    readonly groupId: Schema.Page.GroupId;
+    readonly region: string;
+    readonly slug?: string;
+    readonly pages: ReadonlyArray<PageSummary.PageRef>;
+    readonly status: PageSummary.Status;
+    constructor(args: PageSummary.ConstructorArgs);
+    get type(): Schema.Page.Type;
+    get variant(): Schema.Page.Variant;
+    get hasPages(): boolean;
+    hasLanguage(language: Language): boolean;
+    getPage(language: Language): PageSummary.PageRef | undefined;
+    getClosestPageRef(language: Language, fallback?: Language): Page.Ref;
+    isInGroup({ template, region }: PageSummary.IsInGroupArgs): boolean;
+}
+export declare namespace PageSummary {
+    type Status = 'draft' | 'ready' | 'live' | 'unpublished' | 'changed' | 'empty';
+    type ConstructorArgs = {
+        template: Schema.Page;
+        brand: string;
+        groupId: Schema.Page.GroupId;
+        region: string;
+        slug?: string;
+        pages: PageSummary.PageRef[];
+    };
+    type PageRef = Schema.Page.Data.AsGroup.Instance & Pick<Schema.Page.Data.AsLink, 'state' | 'errors' | 'createdOn' | 'updatedOn' | 'publishedOn'>;
+    type IsInGroupArgs = {
+        template: Schema.Page;
+        region: string;
+    };
+}

package/dist/core/domain/PageSummary.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageSummary = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class PageSummary {
+    constructor(args) {
+        // initialize instance variables
+        this.template = args.template;
+        this.brand = args.brand;
+        this.groupId = args.groupId;
+        this.region = args.region;
+        this.slug = args.slug;
+        this.pages = args.pages;
+        this.status = getStatus(args.pages);
+    }
+    get type() {
+        return this.template.type;
+    }
+    get variant() {
+        return this.template.variant;
+    }
+    get hasPages() {
+        return this.groupId !== funnel_core_1.Schema.Page.GroupId.empty;
+    }
+    hasLanguage(language) {
+        return this.pages.some(page => page.language === language);
+    }
+    getPage(language) {
+        return this.pages.find(page => page.language === language);
+    }
+    getClosestPageRef(language, fallback) {
+        var _a, _b;
+        const { template, brand, groupId, region, pages } = this;
+        const ref = (_b = (_a = pages.find(page => page.language === language)) !== null && _a !== void 0 ? _a : (fallback && pages.find(page => page.language === fallback))) !== null && _b !== void 0 ? _b : pages[0];
+        return Object.assign(Object.assign({}, ref), { template,
+            brand,
+            groupId,
+            region, tags: template.tags.flatMap(tagGroup => tagGroup.parse(ref.tags)) });
+    }
+    isInGroup({ template, region }) {
+        return this.template.type === template.type
+            && this.region === region;
+    }
+}
+exports.PageSummary = PageSummary;
+// helpers
+function getStatus(pages) {
+    // skip if empty
+    if (pages.length === 0) {
+        return 'empty';
+    }
+    // prioritize unpublished
+    else if (allUnpublished(pages)) {
+        return 'unpublished';
+    }
+    // then ready-to-publish
+    else if (hasReadyToPublish(pages)) {
+        return 'ready';
+    }
+    // then completed drafts
+    else if (hasUpdates(pages) || hasUnpublished(pages)) {
+        return 'changed';
+    }
+    // then draft
+    else if (hasDrafts(pages)) {
+        return 'draft';
+    }
+    // otherwise, we're live
+    else {
+        return 'live';
+    }
+}
+function allUnpublished(pages) {
+    return pages.every(page => page.state === 'unpublished');
+}
+function hasUnpublished(pages) {
+    return pages.some(page => page.state === 'unpublished');
+}
+function hasDrafts(pages) {
+    return pages.some(page => page.state === 'draft' && !page.publishedOn);
+}
+function hasReadyToPublish(pages) {
+    return pages.some(page => page.state === 'draft' && !page.errors);
+}
+function hasUpdates(pages) {
+    return pages.some(page => page.state === 'draft' && page.publishedOn);
+}

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

@@ -0,0 +1,37 @@
+import { EventBus, Schema } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { PageSummary } from './PageSummary';
+import { Site } from './Site';
+export declare class Pages {
+    readonly site: Site;
+    readonly pageType: Schema.Page.Type;
+    readonly tags: ReadonlyArray<Schema.Tag>;
+    private readonly _eventBus;
+    private _state;
+    private _items;
+    constructor(args: Pages.ConstructorArgs);
+    get events$(): Observable<Pages.Event>;
+    get template(): Schema.Page<Schema.Page.Content, string>;
+    get state(): Site.State;
+    private set state(value);
+    get ready(): boolean;
+    get items(): ReadonlyArray<PageSummary>;
+    sync(): Promise<void>;
+    private raiseEvent;
+}
+export declare namespace Pages {
+    type State = 'uninitialized' | 'initializing' | 'ready' | 'syncing' | 'error';
+    type ConstructorArgs = {
+        site: Site;
+        pageType: Schema.Page.Type;
+        tags?: ReadonlyArray<Schema.Tag>;
+    };
+    interface Event extends EventBus.Event<'PageCollection', Event.Type> {
+        collection: Pages;
+    }
+    namespace Event {
+        type Type = 'changed';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}

package/dist/core/domain/Pages.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pages = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const PageSummary_1 = require("./PageSummary");
+// model
+class Pages {
+    constructor(args) {
+        var _a;
+        // initialize instance variables
+        this.site = args.site;
+        this.pageType = args.pageType;
+        this.tags = (_a = args.tags) !== null && _a !== void 0 ? _a : [];
+        this._eventBus = new funnel_core_1.EventBus();
+        this._state = 'uninitialized';
+        this._items = [];
+        // force sync
+        this.sync().catch(console.error);
+    }
+    get events$() {
+        return this._eventBus.events$;
+    }
+    get template() {
+        return this.site.getPageSchema(this.pageType);
+    }
+    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() {
+        return this._items;
+    }
+    async sync() {
+        // ignore if already syncing
+        if (this._state === 'syncing') {
+            console.warn('[PageCollection/sync] ignoring redundant sync() call');
+            return;
+        }
+        // get site map
+        try {
+            console.debug('[PageCollection/sync] syncing');
+            // mark as syncing
+            this.state = this._state === 'uninitialized'
+                ? 'initializing'
+                : 'syncing';
+            // load all pages for the region
+            const { site, template, pageType, tags } = this;
+            const { brand, region } = site;
+            const { items: pages } = await site.editorApi.searchPages({
+                brand: brand.id,
+                region: region.id,
+                type: pageType,
+                tags: tags.map(tag => tag.data),
+                version: 'draft',
+                pagination: 'all'
+            });
+            console.debug(`[PageCollection/sync] fetched ${pages.length} "${pageType}" pages`);
+            // group/convert the pages into summaries
+            const itemsArgs = [];
+            const itemsArgsMap = new Map();
+            pages.forEach(page => {
+                // look up item (or create it)
+                let args = itemsArgsMap.get(page.groupId);
+                if (!args) {
+                    // create new args
+                    args = {
+                        template,
+                        brand: page.brand,
+                        groupId: page.groupId,
+                        region: region.id,
+                        slug: page.slug,
+                        pages: []
+                    };
+                    // map it
+                    itemsArgs.push(args);
+                    itemsArgsMap.set(page.groupId, args);
+                }
+                // add page to args
+                args.pages.push({
+                    id: page.id,
+                    language: page.language,
+                    slug: page.slug,
+                    name: page.name,
+                    url: page.url,
+                    tags: page.tags,
+                    state: page.state,
+                    errors: page.errors,
+                    createdOn: page.createdOn,
+                    updatedOn: page.updatedOn,
+                    publishedOn: page.publishedOn
+                });
+            });
+            // convert items to summaries
+            this._items = itemsArgs.map(args => new PageSummary_1.PageSummary(args));
+            console.debug(`[PageCollection/sync] synced ${itemsArgs.length} items`);
+            // mark as ready
+            this.state = 'ready';
+        }
+        // TODO: handle error
+        catch (e) {
+            console.error('[PageCollection/sync] sync failed', e);
+            // move to error state
+            this.state = 'error';
+        }
+    }
+    raiseEvent(type) {
+        this._eventBus.publish(Pages.Event.create({ type, collection: this }));
+    }
+}
+exports.Pages = Pages;
+// extension
+(function (Pages) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'PageCollection';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return funnel_core_1.EventBus.createEvent(Object.assign({ domain: 'PageCollection' }, event));
+        }
+        Event.create = create;
+    })(Event = Pages.Event || (Pages.Event = {}));
+})(Pages || (exports.Pages = Pages = {}));

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

@@ -0,0 +1,45 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { Block } from './Block';
+import { Item } from './Item';
+import { ItemBase } from './ItemBase';
+import { SectionBlock } from './SectionBlock';
+export declare class Section extends ItemBase<Section> {
+    readonly schema: Schema.Section;
+    readonly availableBlocks: ReadonlyArray<Block>;
+    private _initialBlocks?;
+    private _blocks;
+    private _modifiedOn?;
+    private _savingOn?;
+    constructor(args: Section.ConstructorArgs);
+    get identifier(): string;
+    get state(): Item.State;
+    get name(): string;
+    get initialBlocks(): readonly SectionBlock<Schema.Block<string, any, any>>[] | undefined;
+    get blocks(): ReadonlyArray<SectionBlock>;
+    get modified(): boolean;
+    get valid(): boolean;
+    get changes(): Section.Changes;
+    get errors(): Section.Errors;
+    bind(parentContext: ItemBase.ParentContext): void;
+    addBlock(identifier: string): SectionBlock<Schema.Block<string, any, any>>;
+    deleteBlock(id: SectionBlock.Id): undefined;
+    moveBlock(blockId: SectionBlock.Id, newIndex: number): SectionBlock<Schema.Block<string, any, any>> | undefined;
+    repair(): void;
+    onSaveStart(): void;
+    onSaveComplete(): void;
+}
+export declare namespace Section {
+    type ConstructorArgs = ItemBase.ConstructorArgs & {
+        schema: Schema.Section;
+        availableBlocks: ReadonlyArray<Block>;
+        blocks?: ReadonlyArray<SectionBlock>;
+    };
+    type Changes = {
+        section: Section;
+        blocks: SectionBlock[];
+    };
+    type Errors = {
+        section: Section;
+        blocks: SectionBlock[];
+    };
+}