@nascentdigital/funnel-editor 4.6.1 → 5.0.1

package/dist/core/repository/PageRepository.js

@@ -15,6 +15,7 @@ exports.PageRepository = void 0;
 const funnel_core_1 = require("@nascentdigital/funnel-core");
 const domain_1 = require("../domain");
 const PageSerializer_1 = require("./PageSerializer");
+const SerializePageUpdate_1 = require("./SerializePageUpdate");
 // class
 class PageRepository {
     constructor(editorApi) {
@@ -91,6 +92,9 @@ class PageRepository {
         // unpublish page
         await this.editorApi.unpublishPage(page.id);
     }
+    async getOverview(args) {
+        return this.editorApi.getPagesOverview(Object.assign(Object.assign({}, args), { version: 'draft' }));
+    }
     serializePageUpdate(page, savables) {
         var _a, _b;
         // root page updates
@@ -158,18 +162,18 @@ class PageRepository {
                 ...rootPageUpdates,
                 ...discover.reduce((updates, block) => {
                     // try to update block
-                    this.serializeBlockUpdate(updates, block, 'discover', savables);
+                    SerializePageUpdate_1.SerializePageUpdate.serializeBlockUpdate(updates, block, 'discover', savables);
                     // keep reducing
                     return updates;
                 }, []),
                 ...content.reduce((updates, item) => {
                     // handle block
                     if (item instanceof domain_1.Block) {
-                        this.serializeBlockUpdate(updates, item, 'content', savables);
+                        SerializePageUpdate_1.SerializePageUpdate.serializeBlockUpdate(updates, item, 'content', savables);
                     }
                     // or section
                     else {
-                        this.serializeSectionUpdate(updates, item, 'content', savables);
+                        SerializePageUpdate_1.SerializePageUpdate.serializeSectionUpdate(updates, item, 'content', savables);
                     }
                     // keep reducing
                     return updates;
@@ -181,282 +185,5 @@ class PageRepository {
             ]
         };
     }
-    serializeSectionUpdate(updates, section, parentPath, savables) {
-        // track insert/update
-        let sectionChanged = false;
-        const path = [parentPath, section.key];
-        const { blocks, initialBlocks = [] } = section;
-        const blockIds = [];
-        blocks.forEach((sectionBlock, index) => {
-            // track id
-            const { id, block } = sectionBlock;
-            blockIds.push(id);
-            // track insert
-            const originalIndex = initialBlocks.findIndex(item => item.id === id);
-            if (originalIndex < 0) {
-                // add as insertion
-                updates.push({
-                    type: 'section.insert',
-                    path,
-                    index,
-                    section: {
-                        type: 'section',
-                        version: section.schema.version
-                    },
-                    block: sectionBlock.value
-                });
-                // mark changed
-                sectionChanged = true;
-                // track nested savables for section-block insertion
-                const fields = [...block.config, ...block.fields];
-                fields.forEach(field => {
-                    if (field.modified) {
-                        savables.push(field);
-                    }
-                });
-            }
-            // recurse update if it's set
-            else if (block.modified) {
-                // track name field
-                if (block.nameField.modified) {
-                    // send update
-                    updates.push({
-                        type: 'section.blockName',
-                        path,
-                        id,
-                        value: funnel_core_1.Schema.TextField.Value.fromData(block.nameField.value) || null
-                    });
-                    // track change
-                    savables.push(block.nameField);
-                }
-                // serialize config fields
-                this.serializeFieldsUpdate(updates, block.config, [...path, id, 'config'], savables);
-                // serialize content fields
-                this.serializeFieldsUpdate(updates, block.fields, [...path, id, 'fields'], savables);
-            }
-        });
-        // track delete/reorder
-        let reordered = false;
-        initialBlocks.forEach(({ id }, index) => {
-            // add to deleted list if the original doesn't exist anymore
-            const blockIndex = blockIds.findIndex(blockId => blockId === id);
-            if (blockIndex < 0) {
-                // delete
-                updates.push({
-                    type: 'section.delete',
-                    path,
-                    id
-                });
-                // track reorder
-                sectionChanged = true;
-            }
-            // or mark reorder if index isn't the same
-            else if (blockIndex !== index) {
-                reordered = true;
-                sectionChanged = true;
-            }
-        });
-        // track reorder
-        if (reordered) {
-            updates.push({
-                type: 'section.reorder',
-                path,
-                ids: blockIds
-            });
-        }
-        // track section change (if any)
-        if (sectionChanged) {
-            savables.push(section);
-        }
-    }
-    serializeBlockUpdate(updates, block, parentPath, savables) {
-        // ignore if block isn't activated
-        if (!block.activated) {
-            return;
-        }
-        // create a new block if it's new
-        else if (block.isNew) {
-            // create update
-            updates.push({
-                type: 'block.create',
-                path: [parentPath, block.key],
-                block: block.value
-            });
-            // track block
-            savables.push(block);
-            // track nested savables for block insertion
-            const fields = [...block.config, ...block.fields];
-            fields.forEach(field => {
-                if (field.modified) {
-                    savables.push(field);
-                }
-            });
-        }
-        // or just track updated fields
-        else {
-            // serialize config fields
-            this.serializeFieldsUpdate(updates, block.config, [parentPath, block.key, 'config'], savables);
-            // serialize content fields
-            this.serializeFieldsUpdate(updates, block.fields, [parentPath, block.key, 'fields'], savables);
-        }
-    }
-    serializeFieldsUpdate(updates, fields, parentPath, savables) {
-        // handle fields in block
-        fields.forEach(field => {
-            if (field instanceof funnel_core_1.Field) {
-                this.serializeFieldUpdate(updates, field, parentPath, savables);
-            }
-            else if (field instanceof funnel_core_1.ObjectField) {
-                this.serializeObjectFieldUpdate(updates, field, parentPath, savables);
-            }
-            else {
-                this.serializeListUpdate(updates, field, parentPath, savables);
-            }
-        });
-        // return changes (for chaining)
-        return updates;
-    }
-    serializeObjectFieldUpdate(updates, field, parentPath, savables) {
-        var _a;
-        // create object if it's new
-        if (field.isNew) {
-            // add insert
-            updates.push({
-                type: 'object.insert',
-                path: [...parentPath, field.id],
-                value: (_a = field.value) !== null && _a !== void 0 ? _a : null
-            });
-            // track save
-            savables.push(field);
-        }
-        // or process subfields
-        else if (field.exists) {
-            // save fields
-            this.serializeFieldsUpdate(updates, field.fields, [...parentPath, field.id], savables);
-            // track save
-            savables.push(field);
-        }
-        // or process opted out field
-        else if (field.optedOut) {
-            // remove field
-            updates.push({
-                type: 'value',
-                path: [...parentPath, field.id],
-                value: null
-            });
-            // track save
-            savables.push(field);
-        }
-    }
-    serializeFieldUpdate(updates, field, parentPath, savables) {
-        var _a;
-        // track change if modified (ignore if field is sandboxed)
-        if (field.modified && !field.sandboxed) {
-            // set field
-            updates.push({
-                type: 'value',
-                path: [...parentPath, field.id],
-                value: ((_a = field.value) !== null && _a !== void 0 ? _a : null)
-            });
-            // track save
-            savables.push(field);
-        }
-    }
-    serializeListUpdate(updates, list, parentPath, savables) {
-        var _a, _b;
-        // create list if it's new
-        if (list.isNew) {
-            // add new list
-            updates.push({
-                type: 'value',
-                path: [...parentPath, list.id],
-                value: funnel_core_1.Schema.Field.Data.newValue('list')
-            });
-            // track save
-            savables.push(list);
-        }
-        // or drop list on opt-out
-        else if (list.optedOut) {
-            // drop list
-            updates.push({
-                type: 'value',
-                path: [...parentPath, list.id],
-                value: null
-            });
-            // track save
-            savables.push(list);
-        }
-        // or if it is modified (otherwise ignore)
-        else if (list.modified) {
-            // add new list if there's nothing and it's new
-            const path = [...parentPath, list.id];
-            const { value: currentValue, items: fields, initialValue } = list;
-            const currentItems = (_a = currentValue === null || currentValue === void 0 ? void 0 : currentValue.value) !== null && _a !== void 0 ? _a : [];
-            const initialItems = (_b = initialValue === null || initialValue === void 0 ? void 0 : initialValue.value) !== null && _b !== void 0 ? _b : [];
-            const fieldIds = [];
-            // track inserts/updates of elements
-            currentItems.forEach((item, index) => {
-                // track id
-                const { id, field } = fields[index];
-                fieldIds.push(item.id);
-                // track insert
-                const originalIndex = initialItems.findIndex(initialItem => initialItem.id === id);
-                if (originalIndex < 0) {
-                    updates.push({
-                        type: 'array.insert',
-                        path,
-                        index,
-                        id,
-                        value: item
-                    });
-                }
-                // track update
-                else if (field.modified) {
-                    // object field updates should be recursed and indexed
-                    if (field instanceof funnel_core_1.ObjectField) {
-                        this.serializeFieldsUpdate(updates, field.fields, [...path, id], savables);
-                    }
-                    // basic field updates can be done inline
-                    else {
-                        updates.push({
-                            type: 'value',
-                            path: [...path, id],
-                            value: item
-                        });
-                    }
-                }
-            });
-            // track delete/reorder
-            let reordered = false;
-            let deleted = 0;
-            initialItems.forEach(({ id }, index) => {
-                // add to deleted list if the original doesn't exist anymore
-                const fieldIndex = fieldIds.findIndex(fieldId => fieldId === id) + deleted;
-                if (fieldIndex < 0) {
-                    updates.push({
-                        type: 'array.delete',
-                        path,
-                        id
-                    });
-                    // track deletion
-                    ++deleted;
-                }
-                // or mark reorder if index isn't the same
-                else if (fieldIndex !== index) {
-                    reordered = true;
-                }
-            });
-            // track reorder
-            if (reordered) {
-                updates.push({
-                    type: 'array.reorder',
-                    path,
-                    ids: fieldIds
-                });
-            }
-            // track save
-            savables.push(list);
-        }
-    }
 }
 exports.PageRepository = PageRepository;

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

@@ -1,5 +1,5 @@
 import { EventBus, Schema } from '@nascentdigital/funnel-core';
-import { Page } from '../domain';
+import { Block, Page, Section, SectionBlock } from '../domain';
 import { PageTarget } from './PageTarget';
 export declare namespace PageSerializer {
     type DeserializePageWithSummaryArgs = Schema.Page.Data.AsGroup & PageTarget & {
@@ -12,4 +12,37 @@ export declare namespace PageSerializer {
         eventBus: EventBus;
     };
     function deserializePage({ flattenedPage, target, eventBus }: DeserializePageArgs): Page;
+    type DeserializeContentArgs = {
+        key: string;
+        eventBus: EventBus;
+        schema: Schema.Section | Schema.Block;
+        content: Schema.Section.Data | Schema.Block.Data | undefined;
+        snapshot: Schema.Section.Data | Schema.Block.Data | undefined;
+    };
+    function deserializeContent({ key, schema, content, eventBus, snapshot }: DeserializeContentArgs): Block | Section;
+    type DeserializeSectionArgs = {
+        key: string;
+        eventBus: EventBus;
+        schema: Schema.Section;
+        content: Schema.Section.Data | undefined;
+        snapshot: Schema.Section.Data | undefined;
+    };
+    function deserializeSection({ key, eventBus, schema, content, snapshot }: DeserializeSectionArgs): Section;
+    type DeserializeSectionBlockArgs = {
+        id: string;
+        key: string;
+        eventBus: EventBus;
+        schema: Schema.Block;
+        content: Schema.Section.Data.ForBlock | undefined;
+        snapshot: Schema.Section.Data.ForBlock | undefined;
+    };
+    function deserializeSectionBlock({ id, key, eventBus, schema, content, snapshot }: DeserializeSectionBlockArgs): SectionBlock;
+    type DeserializeBlockArgs = {
+        key: string;
+        eventBus: EventBus;
+        schema: Schema.Block;
+        content: Schema.Block.Data | undefined;
+        snapshot: Schema.Block.Data | undefined;
+    };
+    function deserializeBlock({ key, eventBus, schema, content: blockContent, snapshot }: DeserializeBlockArgs): Block;
 }

package/dist/core/repository/PageSerializer.js

@@ -103,6 +103,7 @@ var PageSerializer;
             });
         }
     }
+    PageSerializer.deserializeContent = deserializeContent;
     function deserializeSection({ key, eventBus, schema, content, snapshot }) {
         // TODO: handle version mismatch (between schema + content) and upgrading
         if (content && content.version !== schema.version) {
@@ -132,6 +133,7 @@ var PageSerializer;
             exists: content !== undefined
         });
     }
+    PageSerializer.deserializeSection = deserializeSection;
     function deserializeSectionBlock({ id, key, eventBus, schema, content, snapshot }) {
         // create block and return it (upgrade is handled in block deserialization)
         return new domain_1.SectionBlock({
@@ -143,6 +145,7 @@ var PageSerializer;
             exists: true
         });
     }
+    PageSerializer.deserializeSectionBlock = deserializeSectionBlock;
     function deserializeBlock({ key, eventBus, schema, content: blockContent, snapshot }) {
         // throw if there's a type mismatch
         const { type = schema.type, version = schema.version, config = {}, fields = {} } = blockContent !== null && blockContent !== void 0 ? blockContent : {};
@@ -178,4 +181,5 @@ var PageSerializer;
             name: config.name
         });
     }
+    PageSerializer.deserializeBlock = deserializeBlock;
 })(PageSerializer || (exports.PageSerializer = PageSerializer = {}));

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

@@ -0,0 +1,8 @@
+import { Field, FieldList, FieldModel, ObjectField, Schema } from '@nascentdigital/funnel-core';
+import { ICollectionRepository } from './ICollectionRepository';
+export declare namespace SerializeCollectionUpdate {
+    function serializeFieldsUpdate(updates: Schema.Collection.Update[], fields: ReadonlyArray<FieldModel>, parentPath: ReadonlyArray<string>, savables: ICollectionRepository.Savable[]): Schema.Collection.Update[];
+    function serializeObjectFieldUpdate(updates: Schema.Collection.Update[], field: ObjectField, parentPath: ReadonlyArray<string>, savables: ICollectionRepository.Savable[]): void;
+    function serializeFieldUpdate(updates: Schema.Collection.Update[], field: Field, parentPath: ReadonlyArray<string>, savables: ICollectionRepository.Savable[]): void;
+    function serializeListUpdate(updates: Schema.Collection.Update[], list: FieldList, parentPath: ReadonlyArray<string>, savables: ICollectionRepository.Savable[]): void;
+}

package/dist/core/repository/SerializeCollectionUpdate.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeCollectionUpdate = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// namespace
+var SerializeCollectionUpdate;
+(function (SerializeCollectionUpdate) {
+    // helper
+    function serializeFieldsUpdate(updates, fields, parentPath, savables) {
+        // handle fields in block
+        fields.forEach(field => {
+            if (field instanceof funnel_core_1.Field) {
+                serializeFieldUpdate(updates, field, parentPath, savables);
+            }
+            else if (field instanceof funnel_core_1.ObjectField) {
+                serializeObjectFieldUpdate(updates, field, parentPath, savables);
+            }
+            else {
+                serializeListUpdate(updates, field, parentPath, savables);
+            }
+        });
+        // return changes (for chaining)
+        return updates;
+    }
+    SerializeCollectionUpdate.serializeFieldsUpdate = serializeFieldsUpdate;
+    function serializeObjectFieldUpdate(updates, field, parentPath, savables) {
+        var _a;
+        // create object if it's new
+        if (field.isNew) {
+            updates.push({
+                type: 'object.insert',
+                path: [...parentPath, field.id],
+                value: (_a = field.value) !== null && _a !== void 0 ? _a : null
+            });
+            // track save
+            savables.push(field);
+        }
+        // or process subfields
+        else if (field.exists) {
+            // save fields
+            serializeFieldsUpdate(updates, field.fields, [...parentPath, field.id], savables);
+            // track save
+            savables.push(field);
+        }
+        // or process opted out field
+        else if (field.optedOut) {
+            updates.push({
+                type: 'value',
+                path: [...parentPath, field.id],
+                value: null
+            });
+            // track save
+            savables.push(field);
+        }
+    }
+    SerializeCollectionUpdate.serializeObjectFieldUpdate = serializeObjectFieldUpdate;
+    function serializeFieldUpdate(updates, field, parentPath, savables) {
+        var _a;
+        // track change if modified (ignore if field is sandboxed)
+        if (field.modified && !field.sandboxed) {
+            // set field
+            updates.push({
+                type: 'value',
+                path: [...parentPath, field.id],
+                value: ((_a = field.value) !== null && _a !== void 0 ? _a : null)
+            });
+            // track save
+            savables.push(field);
+        }
+    }
+    SerializeCollectionUpdate.serializeFieldUpdate = serializeFieldUpdate;
+    function serializeListUpdate(updates, list, parentPath, savables) {
+        var _a, _b;
+        // create list if it's new
+        if (list.isNew) {
+            // add new list
+            updates.push({
+                type: 'value',
+                path: [...parentPath, list.id],
+                value: funnel_core_1.Schema.Field.Data.newValue('list')
+            });
+            // track save
+            savables.push(list);
+        }
+        // or drop list on opt-out
+        else if (list.optedOut) {
+            // drop list
+            updates.push({
+                type: 'value',
+                path: [...parentPath, list.id],
+                value: null
+            });
+            // track save
+            savables.push(list);
+        }
+        // or skip if not modified
+        else if (list.modified) {
+            // track insert/update
+            const path = [...parentPath, list.id];
+            const { value: currentValue, items: fields, initialValue } = list;
+            const currentItems = (_a = currentValue === null || currentValue === void 0 ? void 0 : currentValue.value) !== null && _a !== void 0 ? _a : [];
+            const initialItems = (_b = initialValue === null || initialValue === void 0 ? void 0 : initialValue.value) !== null && _b !== void 0 ? _b : [];
+            const fieldIds = [];
+            currentItems.forEach((item, index) => {
+                // track id
+                const { id, field } = fields[index];
+                fieldIds.push(item.id);
+                // track insert
+                const originalIndex = initialItems.findIndex(initialItem => initialItem.id === id);
+                if (originalIndex < 0) {
+                    updates.push({
+                        type: 'array.insert',
+                        path,
+                        index,
+                        id,
+                        value: item
+                    });
+                }
+                // track update
+                else if (field.modified) {
+                    // object field updates should be recursed and indexed
+                    if (field instanceof funnel_core_1.ObjectField) {
+                        serializeFieldsUpdate(updates, field.fields, [...path, id], savables);
+                    }
+                    // basic field updates can be done inline
+                    else {
+                        updates.push({
+                            type: 'value',
+                            path: [...path, id],
+                            value: item
+                        });
+                    }
+                }
+            });
+            // track delete/reorder
+            let reordered = false;
+            let deleted = 0;
+            initialItems.forEach(({ id }, index) => {
+                // add to deleted list if the original doesn't exist anymore
+                const fieldIndex = fieldIds.findIndex(fieldId => fieldId === id) + deleted;
+                if (fieldIndex < 0) {
+                    updates.push({
+                        type: 'array.delete',
+                        path,
+                        id
+                    });
+                    // track deletion
+                    ++deleted;
+                }
+                // or mark reorder if index isn't the same
+                else if (fieldIndex !== index) {
+                    reordered = true;
+                }
+            });
+            // track reorder
+            if (reordered) {
+                updates.push({
+                    type: 'array.reorder',
+                    path,
+                    ids: fieldIds
+                });
+            }
+            // track save
+            savables.push(list);
+        }
+    }
+    SerializeCollectionUpdate.serializeListUpdate = serializeListUpdate;
+})(SerializeCollectionUpdate || (exports.SerializeCollectionUpdate = SerializeCollectionUpdate = {}));

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

@@ -0,0 +1,11 @@
+import { Field, FieldList, FieldModel, ObjectField, Schema } from '@nascentdigital/funnel-core';
+import type { Block, Section } from '../domain';
+export declare namespace SerializePageUpdate {
+    type Savable = Section | Block | FieldModel;
+    function serializeSectionUpdate(updates: Schema.Page.Update[], section: Section, parentPath: string, savables: Savable[]): void;
+    function serializeBlockUpdate(updates: Schema.Page.Update[], block: Block, parentPath: string, savables: Savable[]): void;
+    function serializeFieldsUpdate(updates: Schema.Page.Update[], fields: ReadonlyArray<FieldModel>, parentPath: ReadonlyArray<string>, savables: Savable[]): Schema.Page.Update[];
+    function serializeObjectFieldUpdate(updates: Schema.Page.Update[], field: ObjectField, parentPath: ReadonlyArray<string>, savables: Savable[]): void;
+    function serializeFieldUpdate(updates: Schema.Page.Update[], field: Field, parentPath: ReadonlyArray<string>, savables: Savable[]): void;
+    function serializeListUpdate(updates: Schema.Page.Update[], list: FieldList, parentPath: ReadonlyArray<string>, savables: Savable[]): void;
+}