@nascentdigital/funnel-editor-contentful 4.6.7 → 5.0.2

package/dist/collection/controller/useContentfulCollectionController.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContentfulCollectionController = useContentfulCollectionController;
+const components_1 = require("@nascentdigital/funnel-editor/components");
+// hook
+function useContentfulCollectionController() {
+    return (0, components_1.useCollectionController)();
+}

package/dist/collection/domain/Collection.d.ts

@@ -0,0 +1,108 @@
+import { AssetClient, CollectionClient } from '@nascentdigital/funnel-cms';
+import { ContentfulCollectionData, ContentfulData } from '@nascentdigital/funnel-cms/contentful';
+import { EventBus, Field, FieldModel, Language, Schema } from '@nascentdigital/funnel-core';
+import { Asset, CollectionFieldProxy, CollectionGroup, ICollection, IPage } from '@nascentdigital/funnel-editor/components';
+import { Observable } from 'rxjs';
+export declare class Collection implements ICollection {
+    readonly template: Schema.Collection;
+    readonly eventBus: EventBus;
+    readonly id: Schema.Collection.Id;
+    readonly groupId: Schema.Collection.GroupId;
+    readonly brand?: string;
+    readonly language: Language;
+    readonly version: number;
+    readonly nameField: Field<Schema.TextField>;
+    readonly pageIds: Schema.Page.Id[];
+    private _initialTags;
+    private readonly _tags;
+    readonly fields: ReadonlyArray<FieldModel>;
+    private readonly _assets;
+    private readonly _collections;
+    private readonly _pages;
+    readonly createdOn: number;
+    private _updatedOn;
+    private _modifiedOn?;
+    readonly publishedOn?: number;
+    private readonly _subscription;
+    private _state;
+    private _initialErrors;
+    private _syncing;
+    private _savingOn?;
+    readonly references: Readonly<ContentfulData.References>;
+    constructor(args: Collection.ConstructorArgs);
+    get events$(): Observable<ICollection.Events>;
+    get stable$(): Observable<boolean>;
+    get state(): Schema.Collection.State;
+    private set state(value);
+    get syncing(): boolean;
+    set syncing(syncing: boolean);
+    get type(): Schema.Collection.Type;
+    get modified(): boolean;
+    get changes(): ICollection.Changes;
+    get initialErrors(): boolean;
+    get errors(): ICollection.Errors;
+    get valid(): boolean;
+    get allFields(): FieldModel[];
+    get name(): string;
+    set name(name: string);
+    get published(): boolean;
+    get updatedOn(): number;
+    get assets(): ReadonlyArray<Asset>;
+    get collections(): ReadonlyArray<Schema.Collection.Data.AsLink>;
+    get tagGroups(): ReadonlyArray<Schema.TagGroup>;
+    get initialTags(): ReadonlySet<Schema.Tag<string, string>>;
+    get tags(): ReadonlySet<Schema.Tag>;
+    hydrateStores(references: ICollection.References): void;
+    getAssetScope(range: Schema.AssetScope.Range): Schema.AssetScope;
+    getSearchScope(): AssetClient.GetAssets.Scope;
+    getAsset(id: Asset.Id): Asset | undefined;
+    addAsset(asset: Asset): void;
+    removeAsset(assetId: Asset.Id): boolean;
+    getCollection(collectionId: Schema.Collection.Id): Schema.Collection.Data.AsLink | undefined;
+    addCollection(collection: Schema.Collection.Data.AsLink): void;
+    removeCollection(collectionId: Schema.Collection.Id): boolean;
+    getPageRef(pageId: Schema.Page.Id | undefined): IPage.Ref | undefined;
+    addPageRef(page: IPage.Ref): void;
+    removePageRef(pageId: Schema.Page.Id): boolean;
+    addTag(tag: Schema.Tag): void;
+    removeTag(tag: Schema.Tag): void;
+    onSaveStart(): void;
+    onSaveComplete(updatedOn: number): void;
+    private raiseEvent;
+}
+export declare namespace Collection {
+    type ConstructorArgs = {
+        template: Schema.Collection;
+        eventBus: EventBus;
+        id: Schema.Collection.Id;
+        groupId: Schema.Collection.GroupId;
+        brand?: string;
+        language: Language;
+        version: number;
+        name: string;
+        tags: Schema.Tag[];
+        fields: FieldModel[];
+        files?: Asset[];
+        collections?: Schema.Collection.Data.AsLink[];
+        pageIds?: Schema.Page.Id[];
+        state: Schema.Collection.State;
+        errors: boolean;
+        changeSetId?: Schema.ChangeSet.Id;
+        snapshotId?: Schema.CollectionSnapshot.Id;
+        snapshot?: Schema.CollectionSnapshot;
+        createdOn: number;
+        updatedOn: number;
+        publishedOn?: number;
+        references: ContentfulData.References;
+    };
+    type WithGroup = {
+        group: CollectionGroup;
+        collection?: Collection;
+    };
+    type FromSchemaData = {
+        data: ContentfulCollectionData.ForSchema;
+        references?: Schema.Collection.References;
+    };
+    function fromSchemaData({ data, references }: FromSchemaData): Collection;
+    function toUpdates(collection: Collection | CollectionFieldProxy, savables: ICollection.Savable[]): CollectionClient.Update.Args;
+}

package/dist/collection/domain/Collection.js

@@ -0,0 +1,386 @@
+"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.Collection = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const rxjs_1 = require("rxjs");
+// class
+class Collection {
+    constructor(args) {
+        var _a, _b, _c, _d;
+        // initialize instance variables
+        this.template = args.template;
+        this.eventBus = args.eventBus;
+        this.id = args.id;
+        this.groupId = args.groupId;
+        this.brand = args.brand;
+        this.language = args.language;
+        this.version = args.version;
+        this.nameField = new funnel_core_1.Field({
+            id: 'name',
+            name: 'Name',
+            schema: funnel_core_1.Schema.Field.text({
+                name: 'Name',
+                description: `This is the name used to identify this ${args.template.name}.`,
+                hint: 'Please provide a name',
+                semantics: 'short',
+                required: true
+            }),
+            eventBus: args.eventBus,
+            initialValue: funnel_core_1.Schema.TextField.Value.toData(args.name),
+            publishedValue: funnel_core_1.Schema.TextField.Value.coerceData((_a = args.snapshot) === null || _a === void 0 ? void 0 : _a.name),
+            required: true
+        });
+        this._initialTags = new Set(args.tags);
+        this.pageIds = (_b = args.pageIds) !== null && _b !== void 0 ? _b : [];
+        this._tags = new Set(args.tags);
+        this.fields = args.fields;
+        this._assets = (_c = args.files) !== null && _c !== void 0 ? _c : [];
+        this._collections = (_d = args.collections) !== null && _d !== void 0 ? _d : [];
+        this._pages = [];
+        this.createdOn = args.createdOn;
+        this._updatedOn = args.updatedOn;
+        this.publishedOn = args.publishedOn;
+        this.references = args.references;
+        this._state = args.state;
+        this._initialErrors = args.errors;
+        this._syncing = false;
+        // 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')
+            || (components_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 modified() {
+        const { nameField, initialTags, _tags, fields, initialErrors } = this;
+        return nameField.modified
+            || initialTags.symmetricDifference(_tags).size > 0
+            || fields.some(field => field.modified)
+            || initialErrors !== (this.errors.fields.length > 0);
+    }
+    get changes() {
+        return {
+            collection: this,
+            fields: this.allFields.filter(field => field.changed)
+        };
+    }
+    get initialErrors() {
+        return this._initialErrors;
+    }
+    get errors() {
+        return {
+            collection: this,
+            fields: this.allFields.filter(field => !field.valid)
+        };
+    }
+    get valid() {
+        return this.errors.fields.length === 0;
+    }
+    get allFields() {
+        const { nameField, fields } = this;
+        return [nameField, ...fields];
+    }
+    get name() {
+        var _a;
+        return (_a = funnel_core_1.Schema.TextField.Value.fromData(this.nameField.value)) !== null && _a !== void 0 ? _a : '';
+    }
+    set name(name) {
+        this.nameField.value = funnel_core_1.Schema.TextField.Value.toData(name);
+    }
+    get published() {
+        return this.publishedOn !== undefined;
+    }
+    get updatedOn() {
+        return this._updatedOn;
+    }
+    get assets() {
+        return this._assets;
+    }
+    get collections() {
+        return this._collections;
+    }
+    get tagGroups() {
+        return this.template.tags;
+    }
+    get initialTags() {
+        return this._initialTags;
+    }
+    get tags() {
+        return this._tags;
+    }
+    hydrateStores(references) {
+        this._assets.push(...references.assets);
+        this._collections.push(...references.collections);
+    }
+    getAssetScope(range) {
+        switch (range) {
+            case 'global':
+                return funnel_core_1.Schema.AssetScope.global;
+            case 'type':
+                return new funnel_core_1.Schema.CollectionTypeAssetScope(this.type);
+            case 'instance':
+                return new funnel_core_1.Schema.CollectionInstanceAssetScope(this.groupId);
+        }
+    }
+    getSearchScope() {
+        return {
+            target: 'collection',
+            type: this.type,
+            groupId: this.groupId
+        };
+    }
+    getAsset(id) {
+        return this._assets.find(asset => asset.value.id === id);
+    }
+    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
+        _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;
+    }
+    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;
+        }
+        // add tag
+        _tags.delete(tag);
+        this._modifiedOn = Date.now();
+        // raise event
+        this.raiseEvent('modified');
+    }
+    onSaveStart() {
+        this._savingOn = Date.now();
+    }
+    onSaveComplete(updatedOn) {
+        // update fundamentals
+        this._updatedOn = updatedOn;
+        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._initialTags = new Set(this._tags);
+        }
+        // clear saving flag
+        delete this._savingOn;
+    }
+    raiseEvent(type) {
+        this.eventBus.publish(components_1.ICollection.Event.create({ type, collection: this }));
+    }
+}
+exports.Collection = Collection;
+// extension
+(function (Collection) {
+    function fromSchemaData({ data, references }) {
+        // setup
+        const { snapshot, fields, tags } = data, collectionArgs = __rest(data, ["snapshot", "fields", "tags"]);
+        const { files = {}, collections = {} } = references !== null && references !== void 0 ? references : {};
+        const { fields: fieldsSnapshot = {} } = snapshot !== null && snapshot !== void 0 ? snapshot : {};
+        const template = funnel_core_1.Schema.Site.getCollection(data.type);
+        const eventBus = new funnel_core_1.EventBus();
+        // create collection
+        return new Collection(Object.assign(Object.assign({}, collectionArgs), { eventBus,
+            template, tags: components_1.TagSerializer.deserializeTags({
+                groups: template.tags,
+                tagsData: tags !== null && tags !== void 0 ? tags : []
+            }), fields: Object.entries(template.editableFields).map(([id, schema]) => components_1.FieldSerializer.deserializeField({
+                id,
+                eventBus,
+                schema,
+                content: fields[id],
+                snapshot: fieldsSnapshot[id]
+            })), files: Object.values(files), collections: Object.values(collections) }));
+    }
+    Collection.fromSchemaData = fromSchemaData;
+    function toUpdates(collection, savables) {
+        // add name updates
+        const { id, nameField, name, initialTags, tags, fields, initialErrors, valid } = collection;
+        const updates = [];
+        if (nameField.modified) {
+            updates.push({
+                type: 'collection',
+                property: 'name',
+                value: name
+            });
+            // track change
+            savables.push(nameField);
+        }
+        // add tag updates
+        if (initialTags.symmetricDifference(tags).size > 0) {
+            updates.push({
+                type: 'collection',
+                property: 'tags',
+                value: Array.from(tags).map(tag => tag.data)
+            });
+        }
+        // add errors updates
+        if (initialErrors !== !valid) {
+            updates.push({
+                type: 'collection',
+                property: 'errors',
+                value: !valid
+            });
+        }
+        // add fields
+        components_1.SerializeCollectionUpdate.serializeFieldsUpdate(updates, fields, ['fields'], savables);
+        // return updates
+        return {
+            id,
+            updates,
+            updatedOn: Date.now()
+        };
+    }
+    Collection.toUpdates = toUpdates;
+})(Collection || (exports.Collection = Collection = {}));

package/dist/collection/domain/index.d.ts

@@ -0,0 +1 @@
+export * from './Collection';

package/dist/collection/domain/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Collection"), exports);

package/dist/collection/index.d.ts

@@ -0,0 +1,3 @@
+export * from './screens';
+export * from './controller';
+export * from './repository';

package/dist/collection/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./screens"), exports);
+__exportStar(require("./controller"), exports);
+__exportStar(require("./repository"), exports);

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

@@ -0,0 +1,49 @@
+import { EditorAppSDK, EntrySys } from '@contentful/app-sdk';
+import { ContentfulContentClient } from '@nascentdigital/funnel-cms/contentful';
+import { Schema } from '@nascentdigital/funnel-core';
+import { CollectionFieldProxy, CollectionGroup, ICollection, ICollectionRepository } from '@nascentdigital/funnel-editor/components';
+import { Collection } from '../domain';
+export declare class CollectionRepository implements ICollectionRepository {
+    readonly sdk: EditorAppSDK;
+    readonly contentfulClient: ContentfulContentClient;
+    constructor(args: CollectionRepository.ConstructorArgs);
+    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>;
+    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>;
+    update(args: ICollectionRepository.Update.Args): Promise<ICollectionRepository.Update.Result>;
+    serializeUpdate(collection: ICollection | CollectionFieldProxy, savables: ICollection.Savable[]): ICollectionRepository.SerializeUpdates.Result;
+    load(sys?: EntrySys): Promise<CollectionRepository.Load.Result>;
+    save(collection: Collection): Promise<Collection>;
+    sync({ collection, sys }: CollectionRepository.Sync.Args): Promise<CollectionRepository.Sync.Result>;
+    unpublish(collection: ICollection): Promise<void>;
+}
+export declare namespace CollectionRepository {
+    type ConstructorArgs = {
+        sdk: EditorAppSDK;
+        contentfulClient: ContentfulContentClient;
+    };
+    namespace Load {
+        type Args = {
+            collectionId?: Schema.Collection.Id;
+        };
+        type Result = {
+            collectionGroup: CollectionGroup;
+            collection: Collection;
+            sys: EntrySys;
+        };
+    }
+    namespace Sync {
+        type Args = {
+            collection: Collection;
+            sys: EntrySys;
+        };
+        type Result = {
+            collectionGroup?: CollectionGroup;
+            collection: Collection;
+            sys: EntrySys;
+        };
+    }
+}