@nascentdigital/funnel-core 4.4.4

package/dist/schema/PageModel.js

@@ -0,0 +1,881 @@
+"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.PageModel = void 0;
+const app_1 = require("../app");
+const errors_1 = require("../errors");
+const regionalization_1 = require("../regionalization");
+const utils_1 = require("../utils");
+const field_1 = require("./field");
+const Page_1 = require("./Page");
+const PageRoute_1 = require("./PageRoute");
+const Seo_1 = require("./Seo");
+const Site_1 = require("./Site");
+// class
+class PageModel {
+    constructor(data) {
+        this.data = data;
+    }
+    get schema() {
+        const { data: page } = this;
+        const { region } = page;
+        const schemas = Site_1.Site.current().regions[region];
+        return schemas[page.type];
+    }
+    get seo() {
+        var _a;
+        return (_a = this.data.discover) === null || _a === void 0 ? void 0 : _a.seo;
+    }
+    /**
+     * Synchronizes computed properties with the latest `PageModel` data (e.g. updating `url` from route template or name)
+     */
+    sync() {
+        var _a;
+        // update url
+        const { data: page } = this;
+        page.url = this.computeUrl();
+        // update name
+        page.name = this.computeName();
+        // update preview
+        page.preview = (_a = this.computePreview()) !== null && _a !== void 0 ? _a : undefined;
+    }
+    /**
+     * Applies updates *in place* to the underlying `Page.Data`.
+     *
+     * @param updates - a collection of updates to be applied to this page.
+     */
+    update(updates) {
+        // apply updates
+        updates.forEach(update => {
+            switch (update.type) {
+                case 'tags':
+                    this.updateTags(update);
+                    break;
+                case 'block.create':
+                    this.updateBlockCreate(update);
+                    break;
+                case 'block.delete':
+                    this.updateBlockDelete(update);
+                    break;
+                case 'section.insert':
+                    this.updateSectionInsert(update);
+                    break;
+                case 'section.delete':
+                    this.updateSectionDelete(update);
+                    break;
+                case 'section.reorder':
+                    this.updateSectionReorder(update);
+                    break;
+                case 'section.blockName':
+                    this.updateSectionBlockName(update);
+                    break;
+                case 'object.insert':
+                    this.updateObjectInsert(update);
+                    break;
+                case 'array.insert':
+                    this.updateArrayInsert(update);
+                    break;
+                case 'array.delete':
+                    this.updateArrayDelete(update);
+                    break;
+                case 'array.reorder':
+                    this.updateArrayReorder(update);
+                    break;
+                case 'value':
+                    this.updateValue(update);
+                    break;
+            }
+        });
+        // finally, sync the model
+        this.sync();
+    }
+    updateTags(update) {
+        // replace slug
+        const { data: page } = this;
+        page.tags = update.tags;
+    }
+    updateBlockCreate(update) {
+        var _a;
+        // resolve target
+        const { data: page } = this;
+        const { area, path } = PageModel.TargetArea.extract(update.path);
+        const root = ((_a = page[area]) !== null && _a !== void 0 ? _a : {});
+        // fail if there isn't a single key
+        if (path.length !== 1) {
+            console.error(`[PageChanges/updateBlockCreate] Invalid block path "${path.join(',')}"`);
+            throw new errors_1.ArgumentError(`Block path is invalid: [${path.join(',')}]`);
+        }
+        // skip if page has an entry already at the path
+        const [key] = path;
+        if (key in root) {
+            console.warn(`[PageChanges/updateBlockCreate] Block already exists in "${area}" for key "${key}"`);
+            return;
+        }
+        // or add the block
+        else {
+            console.debug(`[PageChanges/updateBlockCreate] added Block to "${area}" at "${key}"`, update.block);
+            root[key] = update.block;
+        }
+    }
+    updateBlockDelete(update) {
+        var _a;
+        // resolve target
+        const { data: page } = this;
+        const { area, path } = PageModel.TargetArea.extract(update.path);
+        const root = ((_a = page[area]) !== null && _a !== void 0 ? _a : {});
+        // fail if there isn't a single key
+        if (path.length !== 1) {
+            console.error(`[PageChanges/updateBlockDelete] Invalid block path "${path.join(',')}"`);
+            throw new errors_1.ArgumentError(`Block path is invalid: [${path.join(',')}]`);
+        }
+        // skip if page has no entry at the path (already deleted?)
+        const [key] = path;
+        if (!(key in root)) {
+            console.warn(`[PageChanges/updateBlockDelete] Block no longer exists in "${area}" for key "${key}"`, root);
+            return;
+        }
+        // or delete the block
+        else {
+            console.debug(`[PageChanges/updateBlockDelete] deleted Block from "${area}" at "${key}"`);
+            delete root[key];
+        }
+    }
+    updateSectionInsert(_a) {
+        var { block, index } = _a, update = __rest(_a, ["block", "index"]);
+        // resolve target
+        const { data: page } = this;
+        const { area, path } = PageModel.TargetArea.extract(update.path);
+        // blow up if not targeting page content
+        if (area === 'discover' || area === 'preview') {
+            console.error(`[PageChanges/updateSectionInsert] invalid target for Section: "${area}"`);
+            throw new errors_1.ArgumentError(`Section can only be inserted in "content", not "${area}"`);
+        }
+        // blow up if path isn't a single item
+        if (path.length !== 1) {
+            console.error(`[PageChanges/updateSectionInsert] invalid path for Section "${path.join('.')}"`);
+            throw new errors_1.ArgumentError(`Invalid Section path "${path.join('.')}"`);
+        }
+        // add section if it doesn't exist
+        const [sectionKey] = path;
+        const section = page.content[sectionKey];
+        if (!section) {
+            page.content[sectionKey] = Object.assign(Object.assign({}, update.section), { blocks: [block] });
+        }
+        // or blow up if section isn't a section
+        else if (section.type !== 'section') {
+            console.error(`[PageChanges/updateSectionInsert] expected Section but found other type at "${path.join('.')}"`);
+            throw new errors_1.IllegalStateError(`Found non-Section at path "${path.join('.')}"`);
+        }
+        // or fail if block is already in section
+        else if (section.blocks.some(sectionBlock => sectionBlock.section.id === block.section.id)) {
+            console.warn(`[PageChanges/updateSectionInsert] SectionBlock is already in list at "${path.join('.')}" - ignoring`);
+        }
+        // or add to end of section if out-of-bounds
+        else if (index < 0 || index > section.blocks.length) {
+            console.debug(`[PageChanges/updateSectionInsert] item "${block.section.id}" index "${index}" is out of bounds (0, ${section.blocks.length} at "${path.join('.')}" - adding to end:`, block);
+            section.blocks.push(block);
+        }
+        // or insert into section
+        else {
+            console.debug(`[PageChanges/updateSectionInsert] inserting SectionBlock "${block.section.id}" to "${index}" in list at "${path.join('.')}":`, block);
+            section.blocks.splice(index, 0, block);
+        }
+    }
+    updateSectionDelete(_a) {
+        var { id } = _a, update = __rest(_a, ["id"]);
+        // resolve target
+        const { data: page } = this;
+        const { area, path } = PageModel.TargetArea.extract(update.path);
+        // blow up if not targeting page content
+        if (area === 'discover' || area === 'preview') {
+            console.error(`[PageChanges/updateSectionDelete] invalid target for Section: "${area}"`);
+            throw new errors_1.ArgumentError(`Section can only be deleted from "content", not "${area}"`);
+        }
+        // blow up if path isn't a single item
+        if (path.length !== 1) {
+            console.error(`[PageChanges/updateSectionDelete] invalid path for Section "${path.join('.')}"`);
+            throw new errors_1.ArgumentError(`Invalid Section path "${path.join('.')}"`);
+        }
+        // add section if it doesn't exist
+        const [sectionKey] = path;
+        const section = page.content[sectionKey];
+        if ((section === null || section === void 0 ? void 0 : section.type) !== 'section') {
+            console.error(`[PageChanges/updateSectionDelete] encountered non-Section at "${path.join('.')}"`);
+            throw new errors_1.IllegalStateError(`Found non-Section at path "${path.join('.')}"`);
+        }
+        // find section index (skip if it's not there)
+        const index = section.blocks.findIndex(block => block.section.id === id);
+        if (index < 0) {
+            console.warn(`[PageChanges/updateSectionDelete] no SectionBlock with ID "${id}" in list at "${path.join('.')}"`);
+        }
+        // or splice it out
+        else {
+            console.warn(`[PageChanges/updateSectionDelete] removed item "${id}" from list at "${path.join('.')}"`);
+            section.blocks.splice(index, 1);
+        }
+    }
+    updateSectionReorder(_a) {
+        var { ids } = _a, update = __rest(_a, ["ids"]);
+        // resolve target
+        const { data: page } = this;
+        const { area, path } = PageModel.TargetArea.extract(update.path);
+        // blow up if not targeting page content
+        if (area === 'discover' || area === 'preview') {
+            console.error(`[PageChanges/updateSectionReorder] invalid target for Section: "${area}"`);
+            throw new errors_1.ArgumentError(`Section can only be reordered in "content", not "${area}"`);
+        }
+        // blow up if path isn't a single item
+        if (path.length !== 1) {
+            console.error(`[PageChanges/updateSectionReorder] invalid path for Section "${path.join('.')}"`);
+            throw new errors_1.ArgumentError(`Invalid Section path "${path.join('.')}"`);
+        }
+        // add section if it doesn't exist
+        const [sectionKey] = path;
+        const section = page.content[sectionKey];
+        if ((section === null || section === void 0 ? void 0 : section.type) !== 'section') {
+            console.error(`[PageChanges/updateSectionReorder] encountered non-Section at "${path.join('.')}"`);
+            throw new errors_1.IllegalStateError(`Found non-Section at path "${path.join('.')}"`);
+        }
+        // create new array with the correct order - this drops item's that aren't in the intersection
+        const reorderedBlocks = [];
+        ids.forEach(id => {
+            // add Block if it's in the original
+            const block = section.blocks.find(block => block.section.id === id);
+            if (block) {
+                reorderedBlocks.push(block);
+            }
+        });
+        console.error(`[PageChanges/updateSectionReorder] reordered ${reorderedBlocks.length} SectionBlock items at "${path.join('.')}"`);
+        // replace the value
+        section.blocks = reorderedBlocks;
+    }
+    updateSectionBlockName(_a) {
+        var { id } = _a, update = __rest(_a, ["id"]);
+        // resolve target
+        const { data: page } = this;
+        const { area, path } = PageModel.TargetArea.extract(update.path);
+        // blow up if not targeting page content
+        if (area === 'discover' || area === 'preview') {
+            console.error(`[PageChanges/updateSectionBlockName] invalid target for Section: "${area}"`);
+            throw new errors_1.ArgumentError(`Section block can only be named from "content", not "${area}"`);
+        }
+        // blow up if path isn't a single item
+        if (path.length !== 1) {
+            console.error(`[PageChanges/updateSectionBlockName] invalid path for Section "${path.join('.')}"`);
+            throw new errors_1.ArgumentError(`Invalid Section path "${path.join('.')}"`);
+        }
+        // add section if it doesn't exist
+        const [sectionKey] = path;
+        const section = page.content[sectionKey];
+        if ((section === null || section === void 0 ? void 0 : section.type) !== 'section') {
+            console.error(`[PageChanges/updateSectionBlockName] encountered non-Section at "${path.join('.')}"`);
+            throw new errors_1.IllegalStateError(`Found non-Section at path "${path.join('.')}"`);
+        }
+        // find section index (skip if it's not there)
+        const index = section.blocks.findIndex(block => block.section.id === id);
+        if (index < 0) {
+            console.error(`[PageChanges/updateSectionBlockName] no SectionBlock with ID "${id}" in list at "${path.join('.')}"`);
+            throw new errors_1.IllegalStateError(`No SectionBlock with ID "${id}" in list at "${path.join('.')}"`);
+        }
+        // saving user's block name in config
+        const config = section.blocks[index].config;
+        console.debug(`[PageChanges/updateSectionBlockName] set SectionBlock name to "${update.value}" at "${path.join('.')}"`);
+        if (update.value === null) {
+            delete config.name;
+        }
+        else {
+            config.name = update.value;
+        }
+    }
+    updateObjectInsert(_a) {
+        var _b;
+        var { value } = _a, update = __rest(_a, ["value"]);
+        // resolve target
+        const { data: page } = this;
+        const { area, path } = PageModel.TargetArea.extract(update.path);
+        const root = ((_b = page[area]) !== null && _b !== void 0 ? _b : {});
+        const { parentPath, childKey } = splitPath(path);
+        const target = this.find(root, {
+            path: parentPath,
+            parentPath: [area],
+            issues: []
+        });
+        // fail if there's no target (shouldn't happen)
+        if (!target || typeof target !== 'object' || Array.isArray(target)) {
+            console.warn(`[PageModel/updateObjectInsert] could not find object parent at path "${path.join('.')}"`);
+        }
+        // or just add object
+        else {
+            console.debug(`[PageModel/updateObjectInsert] setting object at "${childKey}"`);
+            this.setValue(target, parentPath, childKey, value);
+        }
+    }
+    updateArrayInsert(_a) {
+        var _b;
+        var { index, id, value } = _a, update = __rest(_a, ["index", "id", "value"]);
+        // resolve target
+        const { data: page } = this;
+        const { area, path } = PageModel.TargetArea.extract(update.path);
+        const root = ((_b = page[area]) !== null && _b !== void 0 ? _b : {});
+        let target = this.find(root, {
+            path,
+            parentPath: [area],
+            issues: []
+        });
+        // simply create the array if it doesn't exist
+        if (target === undefined || target === null) {
+            // resolve parent
+            const { parentPath, childKey } = splitPath(path);
+            target = this.find(root, {
+                path: parentPath,
+                parentPath: [area],
+                issues: []
+            });
+            // fail if item's parent isn't found
+            if (!target) {
+                console.warn(`[PageChanges/updateArrayInsert] could not find array parent at path "${path.join('.')}"`);
+            }
+            // or set value
+            else {
+                this.setValue(target, parentPath, childKey, { type: 'list', value: [value] });
+            }
+        }
+        // or fail if target isn't an array
+        else if (target.type !== 'list') {
+            console.warn(`[PageChanges/updateArrayInsert] could not find array at path "${path.join('.')}"`);
+        }
+        // or fail if item is already in list
+        else if (target.value.some(item => item.id === id)) {
+            console.warn(`[PageChanges/updateArrayInsert] item is already in list at "${path.join('.')}" - ignoring`);
+        }
+        // or insert at end if index is out-of-bounds
+        else if (index < 0 || target.value.length < index) {
+            console.debug(`[PageChanges/updateArrayInsert] item "${id}" index "${index}" is out of bounds (0, ${target.value.length} at "${path.join('.')}" - adding to end:`, value);
+            target.value.push(value);
+        }
+        // or insert item at index
+        else {
+            console.debug(`[PageChanges/updateArrayInsert] inserting item "${id}" to "${index}" in list at "${path.join('.')}":`, value);
+            target.value.splice(index, 0, value);
+        }
+    }
+    updateArrayDelete(_a) {
+        var _b;
+        var { id } = _a, update = __rest(_a, ["id"]);
+        // resolve target
+        const { data: page } = this;
+        const { area, path } = PageModel.TargetArea.extract(update.path);
+        const root = ((_b = page[area]) !== null && _b !== void 0 ? _b : {});
+        const target = this.find(root, {
+            path,
+            parentPath: [area],
+            issues: []
+        });
+        // skip if target isn't an array
+        if ((target === null || target === void 0 ? void 0 : target.type) !== 'list') {
+            console.warn(`[PageChanges/updateArrayDelete] could not find array at path "${path.join('.')}"`);
+        }
+        // or remove target
+        else {
+            // find target index (fail if it's not there)
+            const list = target.value;
+            const index = list.findIndex(item => item.id === id);
+            if (index < 0) {
+                console.warn(`[PageChanges/updateArrayDelete] no item with ID "${id}" in list at "${path.join('.')}"`);
+            }
+            // or splice it out
+            else {
+                console.warn(`[PageChanges/updateArrayDelete] removed item "${id}" from list at "${path.join('.')}"`);
+                list.splice(index, 1);
+            }
+        }
+    }
+    updateArrayReorder(_a) {
+        var _b;
+        var { ids } = _a, update = __rest(_a, ["ids"]);
+        // resolve target
+        const { data: page } = this;
+        const { area, path } = PageModel.TargetArea.extract(update.path);
+        const root = ((_b = page[area]) !== null && _b !== void 0 ? _b : {});
+        const target = this.find(root, {
+            path,
+            parentPath: [area],
+            issues: []
+        });
+        // fail if target isn't an array
+        if ((target === null || target === void 0 ? void 0 : target.type) !== 'list') {
+            console.warn(`[PageChanges/updateArrayReorder] could not find array at path "${path.join('.')}"`);
+            return;
+        }
+        // create new array with the correct order - this drops item's that aren't in the intersection
+        const updatedValue = [];
+        ids.forEach(id => {
+            // add item if it's in the original
+            const item = target.value.find(item => item.id === id);
+            if (item) {
+                updatedValue.push(item);
+            }
+        });
+        // replace the value
+        target.value = updatedValue;
+    }
+    updateValue(_a) {
+        var _b;
+        var { value } = _a, update = __rest(_a, ["value"]);
+        console.debug(`[PageChanges/updateValue] executing value update`, { update, value });
+        // resolve target
+        const { data: page } = this;
+        const { area, path } = PageModel.TargetArea.extract(update.path);
+        const root = ((_b = page[area]) !== null && _b !== void 0 ? _b : {});
+        const { parentPath, childKey } = splitPath(path);
+        const target = this.find(root, {
+            path: parentPath,
+            parentPath: [area],
+            issues: []
+        });
+        // skip if target can't be resolved (track issue)
+        if (!target) {
+            // TODO: track issue
+            console.warn(`[PageChanges/applyValueChange] no target to update`);
+            // stop processing
+            return;
+        }
+        // set value
+        this.setValue(target, parentPath, childKey, value);
+        console.warn(`[PageChanges/updateValue] updated value for "${path.join('.')}" to:`, value);
+    }
+    setValue(target, parentPath, key, data) {
+        // update list value
+        if (target.type === 'list') {
+            // add back item if it's gone
+            const items = target.value;
+            const itemIndex = target.value.findIndex(item => item.id === key);
+            if (itemIndex < 0) {
+                console.warn(`[PageChanges/setValue] adding back missing item "${key}"`, data);
+                items.push(data);
+            }
+            // or pave over value
+            else {
+                console.debug(`[PageChanges/setValue] updating ListField at "${key}" to:`, data);
+                items[itemIndex] = data;
+            }
+        }
+        // or update object value
+        else if (target.type === 'object') {
+            console.debug(`[PageChanges/setValue] updating ObjectField at "${key}" to:`, data);
+            // delete entry if there's no data
+            if (data === null || data === undefined) {
+                console.debug(`[PageChanges/setValue] deleting ObjectField at "${key}"`);
+                delete target.value[key];
+            }
+            // or pave over if entry
+            else {
+                console.debug(`[PageChanges/setValue] setting ObjectField at "${key}" to:`, data);
+                const values = target.value;
+                values[key] = data;
+            }
+        }
+        // or update block value
+        else if (target.type === 'block') {
+            // update config
+            const bucket = utils_1.ArrayUtils.last(parentPath);
+            if (bucket === 'config') {
+                // get config (or create it)
+                let config = target.config;
+                if (!config) {
+                    console.debug(`[PageChanges/setValue] creating new config for block at "${parentPath.join('.')}"`);
+                    config = {};
+                    target.config = config;
+                }
+                // delete if there's no value
+                if (data === null || data === undefined) {
+                    console.debug(`[PageChanges/setValue] deleting block config at "${key}"`);
+                    delete config[key];
+                }
+                // or update
+                else {
+                    console.debug(`[PageChanges/setValue] updating block config at "${key}" to:`, data);
+                    config[key] = data;
+                }
+            }
+            // or update fields
+            else if (bucket === 'fields') {
+                console.debug(`[PageChanges/setValue] updating block content at "${key}" to:`, data);
+                target.fields[key] = data;
+            }
+            // or raise error
+            else {
+                console.warn(`[PageChanges/setValue] unrecognized block path at "${parentPath.join('.')}"`);
+            }
+        }
+        // or ignore (this should never happen)
+        else {
+            console.warn(`[PageChanges/setValue] invalid parent found at path "${key}"`, target);
+        }
+    }
+    findValue(path) {
+        var _a;
+        // tokenize path
+        const { data: page } = this;
+        const [areaIdRaw, ...pathComponents] = path.split('.');
+        const areaId = areaIdRaw;
+        switch (areaId) {
+            // handle direct values
+            case 'id':
+            case 'groupId':
+            case 'region':
+            case 'brand':
+            case 'type':
+            case 'slug':
+            case 'url':
+            case 'language':
+            case 'name':
+            case 'errors':
+            case 'state':
+            case 'createdOn':
+            case 'updatedOn':
+            case 'publishedOn':
+                return (_a = page[areaId]) !== null && _a !== void 0 ? _a : undefined;
+            // or search in sections
+            case 'discover':
+            case 'preview':
+            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(`[PageChanges/findValue] TargetPath "${path}" is too short for resolving a value`);
+                    return undefined;
+                }
+                console.debug(`[PageChanges/findValue] resolving TargetPath "${path}"`);
+                // helper (pops keys)
+                const popComponent = () => pathComponents.splice(0, 1)[0];
+                // get area
+                const area = page[areaId];
+                // keep iterating until path is collapsed
+                let target = area[popComponent()];
+                while (pathComponents.length > 0) {
+                    // update
+                    const key = popComponent();
+                    switch (target.type) {
+                        case 'section': {
+                            // find block (or stop)
+                            const sectionBlock = target.blocks.find(({ section: { block } }) => block === key);
+                            if (!sectionBlock) {
+                                console.warn(`[PageChanges/findValue] no Section entry for key "${key}" in TargetPath ${path}`);
+                                return undefined;
+                            }
+                            // update
+                            target = sectionBlock;
+                            break;
+                        }
+                        case 'block': {
+                            // find field data (or stop)
+                            const field = target.fields[key];
+                            if (!field) {
+                                console.warn(`[PageChanges/findValue] no Block entry for key "${key}" in TargetPath ${path}`);
+                                return undefined;
+                            }
+                            // update
+                            target = field;
+                            break;
+                        }
+                        case 'object': {
+                            // find child data (or stop)
+                            const field = target.value[key];
+                            if (!field) {
+                                console.warn(`[PageChanges/findValue] no ObjectField entry for key "${key}" in TargetPath ${path}`);
+                                return undefined;
+                            }
+                            // update
+                            target = field;
+                            break;
+                        }
+                        default:
+                            console.warn(`[PageChanges/findValue] no support for drilling into ${target.type} entry with key ${key} in TargetPath ${path}`);
+                            return undefined;
+                    }
+                }
+                // return underlying value
+                console.debug(`[PageChanges/findValue] returning leaf value for ${target.type}`);
+                switch (target.type) {
+                    // handle supported/direct values
+                    case 'text':
+                    case 'enum':
+                    case 'boolean':
+                    case 'date':
+                        return target.value;
+                    default:
+                        console.warn(`[PageChanges/findValue] no support for ${target.type} leaf value at TargetPath ${path}`);
+                        return undefined;
+                }
+            }
+            // or fail
+            default:
+                throw new errors_1.ArgumentError(`No support for TargetPath "${path}" - unsupported root "${areaId}"`);
+        }
+    }
+    find(root, context) {
+        // skip if there's no path
+        const { path, parentPath } = context;
+        if (path.length === 0) {
+            throw new errors_1.ArgumentError('Cannot resolveTarget of 0 path components');
+        }
+        console.debug(`[PageChanges/find] resolving content target: ${path.join('.')}`);
+        // grab top-level block/section from content
+        const [key, ...remainingPath] = path;
+        const sectionOrBlock = root[key];
+        // ignore if there's no section/block
+        if (!sectionOrBlock) {
+            console.warn(`[PageChanges/find] no Section/Block for key "${key}"`);
+        }
+        // or drill into section
+        else if (sectionOrBlock.type === 'section') {
+            return this.findInSection(sectionOrBlock, Object.assign(Object.assign({}, context), { path: remainingPath, parentPath: [...parentPath, key] }));
+        }
+        // or drill into block
+        else {
+            return this.findInBlock(sectionOrBlock, Object.assign(Object.assign({}, context), { path: remainingPath, parentPath: [...parentPath, key] }));
+        }
+    }
+    findInSection(section, context) {
+        // return section if there's no path
+        const { path, parentPath } = context;
+        if (path.length === 0) {
+            console.debug(`[PageChanges/findInSection] returning Section for: ${parentPath.join('.')}`);
+            return section;
+        }
+        // resolve section block (or bail if it's not there)
+        const [sectionBlockId, ...remainingPath] = path;
+        const sectionBlock = section.blocks.find(sectionBlock => sectionBlock.section.id === sectionBlockId);
+        if (!sectionBlock) {
+            console.warn(`[PageChanges/findInSection] unable to resolve SectionBlock "${sectionBlockId}" in "${parentPath.join('.')}"`);
+            return undefined;
+        }
+        console.debug(`[PageChanges/findInSection] found Section "${sectionBlockId}" in "${parentPath.join('.')}"`);
+        // return section if there are no more components
+        if (remainingPath.length === 0) {
+            console.debug(`[PageChanges/findInSection] no components - returning SectionBlock at: ${path.join('.')}`);
+            return sectionBlock;
+        }
+        // resolve value
+        else {
+            console.debug(`[PageChanges/findInSection] drilling into Block for "${remainingPath.join('.')}"`);
+            return this.findInBlock(sectionBlock, Object.assign(Object.assign({}, context), { path: remainingPath, parentPath: [...parentPath, sectionBlockId] }));
+        }
+    }
+    findInBlock(block, context) {
+        var _a;
+        // return block content if there's no path
+        const { path, parentPath } = context;
+        if (path.length === 1) {
+            console.debug(`[PageChanges/findInBlock] returning Block fields for: ${parentPath.join('.')}`);
+            return block;
+        }
+        // fail if there's not at least 2 keys
+        else if (path.length < 2) {
+            console.warn(`[PageChanges/findInBlock] invalid path for block in "${block.type}/${parentPath.join('.')}"`);
+            return undefined;
+        }
+        // fail if we can't pull the bucket
+        const [bucket, key, ...remainingPath] = path;
+        if (bucket !== 'config' && bucket !== 'fields') {
+            console.warn(`[PageChanges/findInBlock] unrecognized path component "${bucket}" in "${block.type}/${parentPath.join('.')}"`);
+            return undefined;
+        }
+        // resolve item (or bail if it's not there)
+        const blockValue = bucket === 'config'
+            ? ((_a = block.config) !== null && _a !== void 0 ? _a : {})[key]
+            : block.fields[key];
+        if (!blockValue) {
+            console.warn(`[PageChanges/findInBlock] unable to resolve Block field "${bucket}/${key}" in "${block.type}/${parentPath.join('.')}"`);
+            return undefined;
+        }
+        // return item if there are no more components
+        else if (remainingPath.length === 0) {
+            console.debug(`[PageChanges/findInBlock] no more components - returning Block value "${bucket}/${key}" at: ${path.join('.')}`);
+            return blockValue;
+        }
+        // resolve value
+        else {
+            console.debug(`[PageChanges/findInBlock] drilling into Block value for "${bucket}/${key}": ${remainingPath.join('.')}`);
+            return this.findInValue(blockValue, Object.assign(Object.assign({}, context), { path: remainingPath, parentPath: [...parentPath, bucket, key] }));
+        }
+    }
+    findInValue(data, context) {
+        // return item if there's no more path components
+        const { path, parentPath } = context;
+        if (path.length === 0) {
+            console.debug(`[PageChanges/findInValue] return leaf value "${parentPath.join('.')}":`, data);
+            return data;
+        }
+        // or return undefined if there's nothing here
+        else if (data === undefined || data === null) {
+            console.warn(`[PageChanges/findInValue] encountered empty Value while navigating "${path.join('.')}" at "${parentPath.join('.')}"`);
+            return data;
+        }
+        // or recurse into an array
+        else if (data.type === 'list') {
+            // skip if entry isn't found
+            const value = data.value;
+            const [itemId, ...remainingPath] = path;
+            const item = value.find(item => item.id === itemId);
+            if (!item) {
+                console.warn(`[PageChanges/findInValue] unable to find array item with ID "${itemId}" at "${parentPath.join('.')}"`);
+                return undefined;
+            }
+            // or recurse
+            else {
+                console.debug(`[PageChanges/findInValue] drilling into item with ID "${itemId}" at "${remainingPath.join('.')}"`, item);
+                return this.findInValue(item, Object.assign(Object.assign({}, context), { path: remainingPath, parentPath: [...parentPath, itemId] }));
+            }
+        }
+        // or recurse into an object
+        else if (data.type === 'object') {
+            // skip if there's no value for the key
+            const [entryKey, ...remainingPath] = path;
+            const entry = data.value[entryKey];
+            if (!entry) {
+                console.warn(`[PageChanges/findInValue] unable to find object entry for key "${entryKey}" at "${parentPath.join('.')}"`);
+                return undefined;
+            }
+            // or recurse
+            else {
+                return this.findInValue(entry, Object.assign(Object.assign({}, context), { path: remainingPath, parentPath: [...parentPath, entryKey] }));
+            }
+        }
+        // or blow up
+        else {
+            throw new errors_1.IllegalStateError(`Unable to recurse into value at "${parentPath.join('.')}" for type "${data.type}"`);
+        }
+    }
+    computeUrl() {
+        // resolve the route
+        const { schema, data: page } = this;
+        const { region, language } = page;
+        const route = regionalization_1.Localized.Maybe.get(schema.route, language);
+        // extract params
+        const keys = Array.from(PageRoute_1.PageRoute.getParams(route));
+        // extract params (if any)
+        const params = keys.reduce((params, path) => {
+            // find value
+            params[path] = String(this.findValue(path));
+            // keep reducing
+            return params;
+        }, {});
+        // get page path (doesn't include localization)
+        const pagePath = PageRoute_1.PageRoute.toUrl(route, params);
+        // use regionalization + locate to create full path
+        const { regionalization } = app_1.AppConfig.brandConfig();
+        const { targetPath } = regionalization_1.Regionalization.getTargetPath({
+            sourceLocale: { region, language },
+            pagePath,
+            regionalization
+        });
+        // return full path
+        return targetPath || '/';
+    }
+    computeName() {
+        var _a, _b, _c, _d, _e;
+        // resolve schema/page
+        const { schema, data: page } = this;
+        const { discover, slug, content } = page;
+        // return fallback if there's no display path
+        const displayPath = schema.displayName;
+        const fallback = schema.variant === 'static'
+            ? schema.name
+            : ((_d = (_c = (_b = (_a = discover === null || discover === void 0 ? void 0 : discover.seo) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b.title) === null || _c === void 0 ? void 0 : _c.value) === null || _d === void 0 ? void 0 : _d.trim()) || slug || schema.name;
+        if (!displayPath) {
+            return fallback;
+        }
+        // try to get the block's field's content (skip if it isn't a block)
+        const [blockId, fieldId] = displayPath.split('.');
+        const block = (content !== null && content !== void 0 ? content : {})[blockId];
+        if (!block || block.type !== 'block') {
+            return fallback;
+        }
+        // get block field value (or use default if there isn't one)
+        const field = block.fields[fieldId];
+        return (_e = field_1.Field.Data.getText(field)) !== null && _e !== void 0 ? _e : fallback;
+    }
+    computePreview() {
+        // resolve schema/page
+        const { schema, data: page } = this;
+        const { preview } = schema;
+        // resolve block data (if any)
+        const blockData = preview
+            ? page.content[preview]
+            : undefined;
+        // return data if it's valid
+        return (blockData === null || blockData === void 0 ? void 0 : blockData.type) === 'block'
+            ? blockData
+            : undefined;
+    }
+    static from(data) {
+        return new PageModel(data);
+    }
+    static fromDraft(data) {
+        console.debug('PageModel.fromDraft', data);
+        const now = Date.now();
+        return new PageModel(Object.assign(Object.assign({}, data), { __root: 'page', id: Page_1.Page.Id.draft, discover: {
+                seo: {
+                    id: Seo_1.Seo.id,
+                    type: Seo_1.Seo.type,
+                    version: Seo_1.Seo.version,
+                    config: {},
+                    fields: {
+                        title: field_1.TextField.Value.toData(data.name),
+                        description: field_1.Field.Data.newValue('text'),
+                        keywords: field_1.Field.Data.newValue('list')
+                    }
+                }
+            }, preview: {}, content: {}, files: [], pages: [], collections: [], errors: true, state: 'draft', createdOn: now, updatedOn: now }));
+    }
+}
+exports.PageModel = PageModel;
+// helpers
+(function (PageModel) {
+    let TargetArea;
+    (function (TargetArea) {
+        function extract([area, ...path]) {
+            // fail if area is invalid
+            if (!filter(area)) {
+                throw new errors_1.ArgumentError(`Invalid TargetArea ${area} in path`);
+            }
+            // return extraction
+            return { area, path };
+        }
+        TargetArea.extract = extract;
+        function filter(key) {
+            switch (key) {
+                case 'discover':
+                case 'preview':
+                case 'content':
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        TargetArea.filter = filter;
+    })(TargetArea = PageModel.TargetArea || (PageModel.TargetArea = {}));
+})(PageModel || (exports.PageModel = PageModel = {}));
+function splitPath(path) {
+    // fail if there are no path elements
+    if (path.length === 0) {
+        throw new errors_1.ArgumentError('Path elements must have a list one segment');
+    }
+    // split
+    const childIndex = path.length - 1;
+    return {
+        parentPath: path.slice(0, childIndex),
+        childKey: path[childIndex]
+    };
+}