@nascentdigital/funnel-editor 4.6.1 → 5.0.1

package/dist/core/hooks/usePageRepository.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageRepositoryContext = void 0;
 exports.usePageRepository = usePageRepository;
 const react_1 = require("react");
-const client_1 = require("../client");
-const repository_1 = require("../repository");
 // hook
 function usePageRepository() {
-    const editorApi = (0, client_1.useEditorApi)();
-    return (0, react_1.useMemo)(() => new repository_1.PageRepository(editorApi), [editorApi]);
+    return (0, react_1.useContext)(exports.PageRepositoryContext);
 }
+// context
+exports.PageRepositoryContext = (0, react_1.createContext)({});

package/dist/core/hooks/useTempFields.d.ts

@@ -1,6 +1,5 @@
-import { Schema } from '@nascentdigital/funnel-core';
-import { TranslateSchema } from '../domain';
-export declare function useTempFields<TFields extends Record<string, Schema.Optional.Maybe<Schema.Field.Type>>>(schemasRaw: TFields, dependencies?: any[]): TranslateSchema.Fields<TFields>;
+import { Schema, SchemaToFields } from '@nascentdigital/funnel-core';
+export declare function useTempFields<TFields extends Record<string, Schema.Optional.Maybe<Schema.Field.Type>>>(schemasRaw: TFields, dependencies?: any[]): SchemaToFields<TFields>;
 export declare namespace useTempFields {
     type Args = {
         schemas: Record<string, Schema.Field.Type>;

package/dist/core/index.d.ts

@@ -2,6 +2,7 @@ export * from './app';
 export * from './auth';
 export * from './client';
 export * from './components';
+export * from './containers';
 export * from './domain';
 export * from './hooks';
 export * from './repository';

package/dist/core/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./app"), exports);
 __exportStar(require("./auth"), exports);
 __exportStar(require("./client"), exports);
 __exportStar(require("./components"), exports);
+__exportStar(require("./containers"), exports);
 __exportStar(require("./domain"), exports);
 __exportStar(require("./hooks"), exports);
 __exportStar(require("./repository"), exports);

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

@@ -0,0 +1,10 @@
+import { EditorApiClient } from '../client';
+import { IAssetRepository } from './IAssetRepository';
+export declare class AssetRepository implements IAssetRepository {
+    editorApi: EditorApiClient;
+    constructor(editorApi: EditorApiClient);
+    search(args: IAssetRepository.Search.Args): Promise<IAssetRepository.Search.Result>;
+    get(args: IAssetRepository.Get.Args): Promise<IAssetRepository.Get.Result>;
+    update(args: IAssetRepository.Update.Args): Promise<IAssetRepository.Update.Result>;
+    uploadFile(args: IAssetRepository.UploadFile.Args): Promise<IAssetRepository.UploadFile.Result>;
+}

package/dist/core/repository/AssetRepository.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetRepository = void 0;
+// class
+class AssetRepository {
+    constructor(editorApi) {
+        this.editorApi = editorApi;
+    }
+    async search(args) {
+        return this.editorApi.getAssets(args);
+    }
+    async get(args) {
+        return this.editorApi.getAsset(args);
+    }
+    async update(args) {
+        return this.editorApi.updateAsset(args);
+    }
+    async uploadFile(args) {
+        return this.editorApi.uploadFile(args);
+    }
+}
+exports.AssetRepository = AssetRepository;

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

@@ -1,29 +1,30 @@
-import { CollectionClient } from '@nascentdigital/funnel-cms';
-import { EventBus, FieldModel } from '@nascentdigital/funnel-core';
+import { Schema } from '@nascentdigital/funnel-core';
 import { UpdateCollectionCommand } from '../../api/collections';
 import { EditorApiClient } from '../client';
 import { Collection, CollectionFieldProxy } from '../domain';
 import { CollectionTarget } from './CollectionTarget';
-export declare class CollectionRepository {
+import { ICollectionRepository } from './ICollectionRepository';
+export declare class CollectionRepository implements ICollectionRepository {
     readonly editorApi: EditorApiClient;
     constructor(editorApi: EditorApiClient);
-    load(args: CollectionTarget.WithEventBus): Promise<import("../domain").CollectionGroup | undefined>;
-    create({ eventBus, ...args }: CollectionRepository.CreateNewArgs): Promise<import("../domain").CollectionGroup>;
-    createLanguage(args: CollectionRepository.CreateLanguageArgs): Promise<import("../domain").CollectionGroup>;
+    load(args: CollectionTarget.WithEventBus): Promise<{
+        collection: Collection | undefined;
+        group: import("../domain").CollectionGroup;
+    } | undefined>;
+    createRaw(args: ICollectionRepository.CreateRaw.Args): Promise<Schema.Collection.Data.AsGroup>;
+    create({ eventBus, ...args }: ICollectionRepository.Create.Args): Promise<{
+        collection: Collection | undefined;
+        group: import("../domain").CollectionGroup;
+    }>;
+    createLanguage(args: ICollectionRepository.CreateLang.Args): Promise<{
+        collection: Collection | undefined;
+        group: import("../domain").CollectionGroup;
+    }>;
     save(collection: Collection): Promise<Collection>;
     unpublish(collection: Collection): Promise<void>;
-    serializeCollectionUpdate(collection: Collection | CollectionFieldProxy, savables: CollectionRepository.Savable[]): UpdateCollectionCommand.Data;
-    private serializeFieldsUpdate;
-    private serializeObjectFieldUpdate;
-    private serializeFieldUpdate;
-    private serializeListUpdate;
-}
-export declare namespace CollectionRepository {
-    type CreateNewArgs = Omit<CollectionClient.Create.NewArgs, 'brand' | 'type' | 'version'> & Pick<Collection.ConstructorArgs, 'template'> & {
-        eventBus?: EventBus;
-    };
-    type CreateLanguageArgs = Omit<CollectionClient.Create.NewLanguageArgs, 'brand'> & Pick<Collection.ConstructorArgs, 'template'> & {
-        eventBus: EventBus;
-    };
-    type Savable = FieldModel;
+    getOverview(args: ICollectionRepository.GetOverview.Args): Promise<ICollectionRepository.GetOverview.Result>;
+    getItems(args: ICollectionRepository.GetItems.Args): Promise<ICollectionRepository.GetItems.Result>;
+    get(args: ICollectionRepository.Get.Args): Promise<ICollectionRepository.Get.Result>;
+    update(args: ICollectionRepository.Update.Args): Promise<ICollectionRepository.Update.Result>;
+    serializeUpdate(collection: Collection | CollectionFieldProxy, savables: ICollectionRepository.Savable[]): UpdateCollectionCommand.Data;
 }

package/dist/core/repository/CollectionRepository.js

@@ -14,6 +14,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionRepository = void 0;
 const funnel_core_1 = require("@nascentdigital/funnel-core");
 const CollectionSerializer_1 = require("./CollectionSerializer");
+const SerializeCollectionUpdate_1 = require("./SerializeCollectionUpdate");
 // class
 class CollectionRepository {
     constructor(editorApi) {
@@ -29,11 +30,15 @@ class CollectionRepository {
         // deserialize collection (if any)
         return CollectionSerializer_1.CollectionSerializer.deserializeCollectionGroup(Object.assign(Object.assign({}, args), data));
     }
-    async create(_a) {
-        var { eventBus } = _a, args = __rest(_a, ["eventBus"]);
+    async createRaw(args) {
         // resolve collection (get or create)
         const { template } = args, query = __rest(args, ["template"]);
-        const data = await this.editorApi.createCollection(Object.assign(Object.assign({}, query), { type: template.type, version: template.version }));
+        return this.editorApi.createCollection(Object.assign(Object.assign({}, query), { type: template.type, version: template.version }));
+    }
+    async create(_a) {
+        var { eventBus } = _a, args = __rest(_a, ["eventBus"]);
+        // create
+        const data = await this.createRaw(args);
         // return collection
         return CollectionSerializer_1.CollectionSerializer.deserializeCollectionGroup(Object.assign(Object.assign({ eventBus: eventBus !== null && eventBus !== void 0 ? eventBus : new funnel_core_1.EventBus() }, args), data));
     }
@@ -46,7 +51,7 @@ class CollectionRepository {
     async save(collection) {
         // get collection update
         const savables = [];
-        const update = this.serializeCollectionUpdate(collection, savables);
+        const update = this.serializeUpdate(collection, savables);
         console.debug('[CollectionRepository/save] created update', update);
         // start all updates
         collection.onSaveStart();
@@ -77,7 +82,19 @@ class CollectionRepository {
         // unpublish collection
         await this.editorApi.unpublishCollection(collection.id);
     }
-    serializeCollectionUpdate(collection, savables) {
+    getOverview(args) {
+        return this.editorApi.getCollectionsOverview(args);
+    }
+    getItems(args) {
+        return this.editorApi.getCollectionItems(args);
+    }
+    get(args) {
+        return this.editorApi.getCollection(args);
+    }
+    async update(args) {
+        return this.editorApi.updateCollection(args);
+    }
+    serializeUpdate(collection, savables) {
         // add name updates
         const { id, nameField, name, initialTags, tags, fields, initialErrors, valid } = collection;
         const updates = [];
@@ -107,7 +124,7 @@ class CollectionRepository {
             });
         }
         // add fields
-        this.serializeFieldsUpdate(updates, fields, ['fields'], savables);
+        SerializeCollectionUpdate_1.SerializeCollectionUpdate.serializeFieldsUpdate(updates, fields, ['fields'], savables);
         // return update data
         return {
             id,
@@ -115,160 +132,5 @@ class CollectionRepository {
             updates
         };
     }
-    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) {
-            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) {
-            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 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) {
-                        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.CollectionRepository = CollectionRepository;

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

@@ -5,7 +5,10 @@ export declare namespace CollectionSerializer {
         template: Schema.Collection;
         eventBus: EventBus;
     };
-    function deserializeCollectionGroup({ template, eventBus, group: groupData, collection: collectionData }: DeserializeCollectionGroupArgs): CollectionGroup;
+    function deserializeCollectionGroup({ template, eventBus, group: groupData, collection: collectionData }: DeserializeCollectionGroupArgs): {
+        collection: Collection | undefined;
+        group: CollectionGroup;
+    };
     type DeserializeCollectionArgs = {
         flattenedCollection: Schema.Collection.FlattenedData;
         template: Schema.Collection;

package/dist/core/repository/CollectionSerializer.js

@@ -27,14 +27,14 @@ var CollectionSerializer;
         });
         // deserialize summary
         const { groupId, brand, name, instances } = groupData;
-        return new domain_1.CollectionGroup({
+        const group = new domain_1.CollectionGroup({
             template,
             groupId,
             brand,
             name,
-            collections: instances,
-            collection
+            collections: instances
         });
+        return { collection, group };
     }
     CollectionSerializer.deserializeCollectionGroup = deserializeCollectionGroup;
     function deserializeCollection({ eventBus, template, flattenedCollection }) {

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

@@ -0,0 +1,25 @@
+import { AssetClient, AssetUploadClient } from '@nascentdigital/funnel-cms';
+export interface IAssetRepository {
+    search(args: IAssetRepository.Search.Args): Promise<IAssetRepository.Search.Result>;
+    get(args: IAssetRepository.Get.Args): Promise<IAssetRepository.Get.Result>;
+    update(args: IAssetRepository.Update.Args): Promise<IAssetRepository.Update.Result>;
+    uploadFile(args: IAssetRepository.UploadFile.Args): Promise<IAssetRepository.UploadFile.Result>;
+}
+export declare namespace IAssetRepository {
+    namespace Search {
+        type Args = AssetClient.GetAssets.Args;
+        type Result = AssetClient.GetAssets.Result;
+    }
+    namespace Get {
+        type Args = AssetClient.GetAsset.Args;
+        type Result = AssetClient.GetAsset.Result;
+    }
+    namespace Update {
+        type Args = AssetClient.UpdateAsset.Args;
+        type Result = AssetClient.UpdateAsset.Result;
+    }
+    namespace UploadFile {
+        type Args = Omit<AssetUploadClient.OnUpload.Args, 'api'>;
+        type Result = AssetUploadClient.OnUpload.Result;
+    }
+}

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

@@ -0,0 +1,62 @@
+import { CollectionClient } from '@nascentdigital/funnel-cms';
+import { EventBus, FieldModel, Schema } from '@nascentdigital/funnel-core';
+import { CollectionFieldProxy, ICollection } from '../domain';
+export interface ICollectionRepository {
+    create(args: ICollectionRepository.Create.Args): Promise<ICollectionRepository.Create.Result>;
+    createRaw(args: ICollectionRepository.CreateRaw.Args): Promise<ICollectionRepository.CreateRaw.Result>;
+    createLanguage(args: ICollectionRepository.CreateLang.Args): Promise<ICollectionRepository.CreateLang.Result>;
+    save(collection: ICollection): Promise<ICollection>;
+    unpublish(collection: ICollection): Promise<void>;
+    getOverview(args: ICollectionRepository.GetOverview.Args): Promise<ICollectionRepository.GetOverview.Result>;
+    getItems(args: ICollectionRepository.GetItems.Args): Promise<ICollectionRepository.GetItems.Result>;
+    get(args: ICollectionRepository.Get.Args): Promise<ICollectionRepository.Get.Result>;
+    update(args: ICollectionRepository.Update.Args): Promise<ICollectionRepository.Update.Result>;
+    serializeUpdate(collection: ICollection | CollectionFieldProxy, savables: ICollectionRepository.Savable[]): ICollectionRepository.SerializeUpdates.Result;
+}
+export declare namespace ICollectionRepository {
+    type Savable = FieldModel;
+    namespace Create {
+        type Args = Omit<CollectionClient.Create.NewArgs, 'brand' | 'type' | 'version'> & {
+            template: Schema.Collection;
+            eventBus?: EventBus;
+        };
+        type Result = ICollection.WithGroup;
+    }
+    namespace CreateRaw {
+        type Args = Omit<CollectionClient.Create.NewArgs, 'brand' | 'type' | 'version'> & {
+            template: Schema.Collection;
+        };
+        type Result = Schema.Collection.Data.AsGroup;
+    }
+    namespace CreateLang {
+        type Args = Omit<CollectionClient.Create.NewLanguageArgs, 'brand'> & {
+            template: Schema.Collection;
+            eventBus: EventBus;
+        };
+        type Result = ICollection.WithGroup;
+    }
+    namespace GetOverview {
+        type Args = Omit<CollectionClient.GetOverview.Args, 'brand'>;
+        type Item = {
+            template: Schema.Collection;
+            type: Schema.Collection.Type;
+            count: number;
+        };
+        type Result = Item[];
+    }
+    namespace GetItems {
+        type Args = Omit<CollectionClient.GetItems.Args, 'brand'>;
+        type Result = CollectionClient.GetItems.Result;
+    }
+    namespace Get {
+        type Args = Omit<CollectionClient.Get.Args, 'brand'>;
+        type Result = CollectionClient.Get.Result;
+    }
+    namespace Update {
+        type Args = CollectionClient.Update.Args;
+        type Result = CollectionClient.Update.Result;
+    }
+    namespace SerializeUpdates {
+        type Result = CollectionClient.Update.Args;
+    }
+}

package/dist/core/repository/ICollectionRepository.js

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

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

@@ -0,0 +1,40 @@
+import { PageClient, Pagination } from '@nascentdigital/funnel-cms';
+import { EventBus, PartialBy, Schema } from '@nascentdigital/funnel-core';
+import { IPage, PageOverview } from '../domain';
+export interface IPageRepository {
+    search(args: IPageRepository.Search.Args): Promise<IPageRepository.Search.Result>;
+    create(args: IPageRepository.Create.Args): Promise<IPageRepository.Create.Result>;
+    createLanguage(args: IPageRepository.CreateLang.Args): Promise<IPageRepository.CreateLang.Result>;
+    save(page: IPage): Promise<IPage>;
+    unpublish(page: IPage): Promise<void>;
+    getOverview(args: IPageRepository.GetOverview.Args): Promise<IPageRepository.GetOverview.Result>;
+}
+export declare namespace IPageRepository {
+    namespace Search {
+        type Args = Omit<PageClient.Search.Args, 'version' | 'brand' | 'type' | 'region'> & {
+            template: Schema.Page;
+            region: string;
+        };
+        type Result = Pagination.Paginated<IPage.Ref>;
+    }
+    namespace Create {
+        type Args = PartialBy<Omit<PageClient.Create.NewArgs, 'brand' | 'type' | 'route'>, 'name'> & {
+            template: Schema.Page;
+            eventBus?: EventBus;
+        };
+        type Result = IPage.WithSummary;
+    }
+    namespace CreateLang {
+        type Args = Omit<PageClient.Create.NewLanguageArgs, 'brand' | 'route'> & {
+            template: Schema.Page;
+            eventBus: EventBus;
+        };
+        type Result = IPage.WithSummary;
+    }
+    namespace GetOverview {
+        type Args = {
+            region: string;
+        };
+        type Result = PageOverview[];
+    }
+}

package/dist/core/repository/IPageRepository.js

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

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

@@ -1,24 +1,20 @@
 import { PageClient, Pagination } from '@nascentdigital/funnel-cms';
 import { EventBus, PartialBy } from '@nascentdigital/funnel-core';
 import { EditorApiClient } from '../client';
-import { Page } from '../domain';
+import { IPage, Page } from '../domain';
+import { IPageRepository } from './IPageRepository';
 import { PageTarget } from './PageTarget';
-export declare class PageRepository {
+export declare class PageRepository implements IPageRepository {
     readonly editorApi: EditorApiClient;
     constructor(editorApi: EditorApiClient);
-    search(args: PageRepository.SearchArgs): Promise<Pagination.Paginated<Page.Ref>>;
+    search(args: PageRepository.SearchArgs): Promise<Pagination.Paginated<IPage.Ref>>;
     load(args: PageRepository.LoadArgs): Promise<Page.WithSummary | undefined>;
     create({ eventBus, name, ...args }: PageRepository.CreateNewArgs): Promise<Page.WithSummary>;
     createLanguage(args: PageRepository.CreateLanguageArgs): Promise<Page.WithSummary>;
     save(page: Page): Promise<Page>;
     unpublish(page: Page): Promise<void>;
+    getOverview(args: IPageRepository.GetOverview.Args): Promise<IPageRepository.GetOverview.Result>;
     private serializePageUpdate;
-    private serializeSectionUpdate;
-    private serializeBlockUpdate;
-    private serializeFieldsUpdate;
-    private serializeObjectFieldUpdate;
-    private serializeFieldUpdate;
-    private serializeListUpdate;
 }
 export declare namespace PageRepository {
     type SearchArgs = Omit<PageClient.Search.Args, 'version' | 'brand' | 'type' | 'region'> & Pick<Page.ConstructorArgs, 'template' | 'region'>;
@@ -29,4 +25,5 @@ export declare namespace PageRepository {
     type CreateLanguageArgs = Omit<PageClient.Create.NewLanguageArgs, 'brand' | 'route'> & Pick<Page.ConstructorArgs, 'template'> & {
         eventBus: EventBus;
     };
+    type GetOverviewArgs = Omit<PageClient.GetOverview.Args, 'brand'>;
 }