@nascentdigital/funnel-editor 4.4.18

package/dist/core/domain/Page.js

@@ -0,0 +1,701 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Page = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const rxjs_1 = require("rxjs");
+const _1 = require("./");
+const PageSettings_1 = require("./PageSettings");
+// class
+class Page {
+    constructor(args) {
+        var _a, _b, _c;
+        // initialize instance variables
+        this.template = args.template;
+        this.eventBus = args.eventBus;
+        this.settings = new PageSettings_1.PageSettings(this);
+        this.id = args.id;
+        this.groupId = args.groupId;
+        this.brand = args.brand;
+        this.region = args.region;
+        this.language = args.language;
+        this.route = funnel_core_1.Localized.Maybe.get(args.template.route, args.language);
+        this._url = args.url;
+        this._initialSlug = this._slug = args.slug;
+        this._initialName = this._name = args.name;
+        this._initialTags = new Set(args.tags);
+        this._tags = new Set(args.tags);
+        this._discover = args.discover;
+        this._content = args.content;
+        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._state = args.state;
+        this._initialErrors = args.errors;
+        this._changeSetId = args.changeSetId;
+        this.snapshotId = args.snapshotId;
+        this.snapshot = args.snapshot;
+        this.createdOn = args.createdOn;
+        this._updatedOn = args.updatedOn;
+        this.publishedOn = args.publishedOn;
+        this._initialPublication = this._publication = args.publication;
+        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')
+            || (_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 syncing() {
+        return this._syncing;
+    }
+    set syncing(syncing) {
+        this._syncing = syncing;
+        this.raiseEvent('changed');
+    }
+    get type() {
+        return this.template.type;
+    }
+    get assets() {
+        return this._assets;
+    }
+    get collections() {
+        return this._collections;
+    }
+    get url() {
+        return this._url;
+    }
+    get hasSlug() {
+        return this.template.variant === 'dynamic';
+    }
+    get initialSlug() {
+        return this._initialSlug;
+    }
+    get slug() {
+        return this._slug;
+    }
+    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 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 initialTags() {
+        return this._initialTags;
+    }
+    get tagGroups() {
+        return this.template.tags;
+    }
+    get tags() {
+        return this._tags;
+    }
+    addTag(tag) {
+        // skip if page has tag
+        const { _tags } = this;
+        if (_tags.has(tag)) {
+            return;
+        }
+        // add tag
+        _tags.add(tag);
+        this._modifiedOn = Date.now();
+        // raise event
+        this.raiseEvent('modified');
+    }
+    removeTag(tag) {
+        // skip if tag isn't there
+        const { _tags } = this;
+        if (!_tags.has(tag)) {
+            return;
+        }
+        // remove tag
+        _tags.delete(tag);
+        this._modifiedOn = Date.now();
+        // raise event
+        this.raiseEvent('modified');
+    }
+    get displayName() {
+        var _a, _b, _c;
+        // return fallback if there's no display path
+        const { template, slug = '', name, seo, content } = this;
+        const path = template.displayName;
+        const fallback = (_c = (_b = (_a = seo.getTextField('title')) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : slug) !== null && _c !== void 0 ? _c : name;
+        if (!path) {
+            return fallback;
+        }
+        // try to get the block's field's content (skip if it isn't a block)
+        const [blockId, fieldId] = path.split('.');
+        const block = content
+            .filter(item => item instanceof _1.Block)
+            .find(item => item.key === blockId);
+        if (!block) {
+            return fallback;
+        }
+        // get block field value (or use default if there isn't one)
+        const field = block.getTextField(fieldId);
+        const value = field === null || field === void 0 ? void 0 : field.value;
+        return value || fallback;
+    }
+    get discover() {
+        return this._discover;
+    }
+    get content() {
+        return this._content;
+    }
+    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;
+    }
+    get blocks() {
+        return this.content
+            .flatMap(item => item instanceof _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 _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 published() {
+        return this.publishedOn !== undefined;
+    }
+    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 changeSetId() {
+        return this._changeSetId;
+    }
+    get valid() {
+        return this.errors.items.length === 0;
+    }
+    get items() {
+        return [...this._discover, ...this._content];
+    }
+    get changes() {
+        return {
+            page: this,
+            items: this.items.filter(item => item instanceof _1.Section
+                ? item.changes.blocks.length > 0
+                : item.changes.fields.length > 0)
+        };
+    }
+    get initialErrors() {
+        return this._initialErrors;
+    }
+    get errors() {
+        return {
+            page: this,
+            items: this.items.filter(item => (!item.activated && item.required)
+                || (item.activated && !item.valid))
+        };
+    }
+    get hasErrors() {
+        return this.errors.items.length > 0;
+    }
+    get asRef() {
+        const { id, groupId, template, brand, region, language, slug, url, name, tags, createdOn, updatedOn, publishedOn } = this;
+        return {
+            id, groupId, template,
+            brand, region, language, slug, url, name, tags: Array.from(tags),
+            createdOn, updatedOn, publishedOn
+        };
+    }
+    /**
+     * Synchronizes computed properties with the latest data (e.g. updating `url` from route template or name)
+     */
+    sync() {
+        // update url
+        this._url = this.computeUrl();
+        // update name
+        this._name = this.computeName();
+    }
+    getItem(identifier) {
+        // skip if there's no identifier
+        if (!identifier) {
+            return undefined;
+        }
+        // or return settings
+        else if (identifier === PageSettings_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 _1.Section) {
+                for (const block of item.blocks) {
+                    // return block if it matches
+                    if (block.identifier === identifier) {
+                        return block;
+                    }
+                }
+            }
+        }
+        // or return undefined
+        return undefined;
+    }
+    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);
+    }
+    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 _1.Block) {
+            console.debug('Removing deleted block', deletedBlock);
+            this._deletedBlocks.push(deletedBlock);
+        }
+        // raise change
+        this.raiseEvent('modified');
+        // indicate success
+        return true;
+    }
+    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
+        };
+    }
+    getAsset(assetId) {
+        return this._assets.find(asset => asset.value.id === assetId);
+    }
+    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(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');
+        }
+        // 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);
+        }
+        // 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;
+    }
+    repair() {
+        // repair all content blocks
+        this.blocks.forEach(block => block.repair());
+    }
+    onSaveStart() {
+        this._savingOn = Date.now();
+    }
+    onSaveComplete(updatedOn, changeSetId) {
+        // update fundamentals
+        this._updatedOn = updatedOn;
+        this._changeSetId = changeSetId;
+        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;
+    }
+    computeName() {
+        var _a, _b, _c, _d, _e, _f;
+        // resolve schema/page
+        const { template, discover, slug } = this;
+        // try to get seo title
+        const seoTitle = (_c = (_b = (_a = discover === null || discover === void 0 ? void 0 : discover[0]) === null || _a === void 0 ? void 0 : _a.getTextField('title')) === null || _b === void 0 ? void 0 : _b.value) === null || _c === void 0 ? void 0 : _c.value.trim();
+        // return fallback if there's no display path
+        const displayPath = template.displayName;
+        const fallback = template.variant === 'static'
+            ? template.name
+            : seoTitle || slug || template.name;
+        if (!displayPath) {
+            return fallback;
+        }
+        // otherwise try to get the block's field's content (fallback if it isn't a block)
+        const [blockId, fieldId] = displayPath.split('.');
+        const block = this.getBlock(blockId);
+        if (!block) {
+            return fallback;
+        }
+        // get the specified field's content
+        return (_f = (_e = (_d = block.getTextField(fieldId)) === null || _d === void 0 ? void 0 : _d.value) === null || _e === void 0 ? void 0 : _e.value.trim()) !== null && _f !== void 0 ? _f : fallback;
+    }
+    computeUrl() {
+        const { template, region, language } = this;
+        const route = funnel_core_1.Localized.Maybe.get(template.route, language);
+        // extract params
+        const keys = Array.from(funnel_core_1.Schema.PageRoute.getParams(route));
+        // extract params (if any)
+        const params = keys.reduce((params, path) => {
+            // find value
+            params[path] = String(this.getValue(path));
+            // keep reducing
+            return params;
+        }, {});
+        // get page path (doesn't include localization)
+        const pagePath = funnel_core_1.Schema.PageRoute.toUrl(route, params);
+        // use regionalization + locate to create full path
+        const { regionalization } = funnel_core_1.AppConfig.brandConfig();
+        const { targetPath } = funnel_core_1.Regionalization.getTargetPath({
+            sourceLocale: { region, language },
+            pagePath,
+            regionalization
+        });
+        // return full path
+        return targetPath || '/';
+    }
+    getValue(path) {
+        // tokenize path
+        const [areaId, ...pathComponents] = path.split('.');
+        switch (areaId) {
+            // handle direct values
+            case 'id':
+            case 'groupId':
+            case 'region':
+            case 'brand':
+            case 'type':
+            case 'slug':
+            case 'url':
+            case 'language':
+            case 'name':
+            case 'state':
+            case 'createdOn':
+            case 'updatedOn':
+            case 'publishedOn':
+                return this[areaId];
+            // or search in sections
+            case 'discover':
+            case 'content': {
+                // fail if there aren't at least 2 more path components (need to reach a section/block value)
+                if (pathComponents.length < 2) {
+                    console.warn(`[Page/getValue] TargetPath "${path}" is too short for resolving a value`);
+                    return undefined;
+                }
+                // helper (pops keys)
+                const popComponent = () => pathComponents.splice(0, 1)[0];
+                // get area within discover/content
+                const itemKey = popComponent();
+                const item = this.getItem(itemKey);
+                if (!item) {
+                    console.warn(`[Page/getValue] no item "${itemKey}" in TargetPath "${path}"`);
+                    return undefined;
+                }
+                if (item instanceof PageSettings_1.PageSettings) {
+                    console.warn(`[Page/getValue] PageSettings not a valid target in in TargetPath "${path}"`);
+                    return undefined;
+                }
+                // keep iterating until path is collapsed
+                let target = item;
+                while (pathComponents.length > 0) {
+                    const key = popComponent();
+                    if (target instanceof _1.Section) {
+                        // find block
+                        const sectionBlock = target.blocks.find(block => block.identifier === key);
+                        if (!sectionBlock) {
+                            console.warn(`[Page/getValue] no Section entry for key "${key}" in TargetPath "'${path}"`);
+                            return undefined;
+                        }
+                        // update
+                        target = sectionBlock;
+                    }
+                    else if (target instanceof _1.Block || target instanceof funnel_core_1.ObjectField || target instanceof _1.SectionBlock) {
+                        // find field
+                        const field = target.fields.find(field => field.id === key);
+                        if (!field) {
+                            console.warn(`[Page/getValue] no entry for key "${key}" in TargetPath "${path}"`);
+                            return undefined;
+                        }
+                        // update
+                        target = field;
+                    }
+                }
+                // return underlying valid type
+                if (target instanceof funnel_core_1.Field && target.value !== undefined) {
+                    const type = target.value.type;
+                    switch (type) {
+                        case 'richtext':
+                        case 'text':
+                        case 'enum':
+                            return funnel_core_1.Schema.Field.Data.getText(target.value);
+                        case 'boolean':
+                        case 'date':
+                            return target.value.value;
+                        default:
+                            console.warn(`[Page/getValue] no support for "${type}" leaf value at TargetPath "${path}"`);
+                            return undefined;
+                    }
+                }
+                // otherwise return undefined
+                else {
+                    console.warn(`[Page/getValue] only Field leaf value at TargetPath "${path}"`);
+                    return undefined;
+                }
+            }
+            // or fail
+            default:
+                throw new funnel_core_1.ArgumentError(`No support for TargetPath "${path}" - unsupported root "${areaId}"`);
+        }
+    }
+    getBlock(identifier) {
+        // try to find item
+        const item = this.getItem(identifier);
+        // make sure it is a block
+        if (item instanceof _1.Block) {
+            return item;
+        }
+        // otherwise undefined
+        else {
+            return undefined;
+        }
+    }
+    raiseEvent(type) {
+        this.eventBus.publish(Page.Event.create({ type, page: this }));
+    }
+}
+exports.Page = Page;
+// types
+(function (Page) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'Page';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return funnel_core_1.EventBus.createEvent(Object.assign({ domain: 'Page' }, event));
+        }
+        Event.create = create;
+    })(Event = Page.Event || (Page.Event = {}));
+})(Page || (exports.Page = Page = {}));