@nascentdigital/funnel-editor-contentful 4.6.7 → 5.0.1

package/dist/core/contentful/ContentfulRefs.js

@@ -0,0 +1,152 @@
+"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.ContentfulRefs = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const ContentfulAsset_1 = require("./ContentfulAsset");
+const ContentfulCollection_1 = require("./ContentfulCollection");
+const ContentfulPage_1 = require("./ContentfulPage");
+// namespace
+var ContentfulRefs;
+(function (ContentfulRefs) {
+    function find(data) {
+        // prepare sets
+        const assets = new Set();
+        const pages = new Set();
+        const collections = new Set();
+        // extract actual refs
+        funnel_core_1.ObjectUtils.walk(data, ({ value }) => {
+            // track assets
+            if (funnel_core_1.Schema.Asset.filter(value)) {
+                // track file (if it's real)
+                const assetId = funnel_core_1.Schema.Asset.getId(value);
+                if (assetId) {
+                    assets.add(assetId);
+                }
+                // don't recurse
+                return false;
+            }
+            // track page links
+            else if (funnel_core_1.Schema.Field.Data.InternalLink.filter(value)) {
+                // track page (only if the id's real)
+                const pageId = funnel_core_1.Schema.Field.Data.InternalLink.getId(value);
+                if (pageId && pageId !== funnel_core_1.Schema.Page.Id.draft) {
+                    pages.add(pageId);
+                }
+                // don't recurse
+                return false;
+            }
+            // transform collection refs
+            else if (funnel_core_1.Schema.Field.Data.Collection.Ref.filter(value)) {
+                // track collection (only if the id's real)
+                const collectionId = funnel_core_1.Schema.Field.Data.Collection.Ref.getId(value);
+                if (collectionId && collectionId !== funnel_core_1.Schema.Collection.Id.draft) {
+                    collections.add(collectionId);
+                }
+                // don't recurse
+                return false;
+            }
+            // transform page refs
+            else if (funnel_core_1.Schema.Field.Data.Page.filter(value)) {
+                // track page (only if the id's real)
+                const pageId = funnel_core_1.Schema.Field.Data.Page.getId(value);
+                if (pageId && pageId !== funnel_core_1.Schema.Page.Id.draft) {
+                    pages.add(pageId);
+                }
+                // don't recurse
+                return false;
+            }
+            // otherwise recurse deeper
+            else {
+                return true;
+            }
+        });
+        // return refs
+        return {
+            assets,
+            pages,
+            collections
+        };
+    }
+    ContentfulRefs.find = find;
+    function serialize(refs, locale) {
+        var _a;
+        // create empty refs
+        const assets = [];
+        const pages = [];
+        const collections = [];
+        // loop over references and serialize
+        const { Entry: entries = [], Asset: files = [] } = (_a = refs.includes) !== null && _a !== void 0 ? _a : {};
+        for (const entry of entries) {
+            switch (entry.sys.contentType.sys.id) {
+                // asset
+                case ContentfulAsset_1.ContentfulAsset.contentTypeId: {
+                    // try to find file
+                    const fileId = entry.fields.media[locale].sys.id;
+                    const file = files.find(file => file.sys.id === fileId);
+                    if (!file) {
+                        throw new funnel_core_1.NotFoundError(`cannot find Contentful media "${fileId}" for asset "${entry.sys.id}"`);
+                    }
+                    assets.push({
+                        __root: 'asset',
+                        type: 'asset',
+                        value: {
+                            id: entry.sys.id,
+                            name: entry.fields.name[locale],
+                            metadata: entry.fields.metadata[locale],
+                            // TODO: add real fields in contentful
+                            brand: 'funnel',
+                            tags: [],
+                            scope: 'global',
+                            type: 'image/png',
+                            url: 'https:' + file.fields.file[locale].url,
+                            description: '',
+                            size: 0
+                        }
+                    });
+                    break;
+                }
+                // page
+                case ContentfulPage_1.ContentfulPage.contentTypeId: {
+                    // convert to link and get template
+                    const pageEntry = entry;
+                    const _b = ContentfulPage_1.ContentfulPage.serializeRemoteLink(pageEntry, locale), { type, tags } = _b, data = __rest(_b, ["type", "tags"]);
+                    const template = funnel_core_1.Schema.Site.getPage(type, data.region);
+                    // push link
+                    pages.push(Object.assign({ template, tags: components_1.TagSerializer.deserializeTags({
+                            groups: template.tags,
+                            tagsData: tags
+                        }) }, data));
+                    break;
+                }
+                // collection
+                case ContentfulCollection_1.ContentfulCollection.contentTypeId: {
+                    // convert to link and get template
+                    const collectionEntry = entry;
+                    const data = ContentfulCollection_1.ContentfulCollection.serializeRemote(collectionEntry, locale);
+                    // push data
+                    collections.push(data);
+                    break;
+                }
+            }
+        }
+        // return
+        return {
+            assets,
+            pages,
+            collections
+        };
+    }
+    ContentfulRefs.serialize = serialize;
+})(ContentfulRefs || (exports.ContentfulRefs = ContentfulRefs = {}));

package/dist/core/contentful/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Contentful';
+export * from './ContentfulAsset';
+export * from './ContentfulCollection';
+export * from './ContentfulPage';
+export * from './ContentfulRefs';

package/dist/core/contentful/index.js

@@ -0,0 +1,21 @@
+"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("./Contentful"), exports);
+__exportStar(require("./ContentfulAsset"), exports);
+__exportStar(require("./ContentfulCollection"), exports);
+__exportStar(require("./ContentfulPage"), exports);
+__exportStar(require("./ContentfulRefs"), exports);

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

@@ -0,0 +1,99 @@
+import { AssetClient } from '@nascentdigital/funnel-cms';
+import { EventBus, Field, FieldModel, Language, Schema } from '@nascentdigital/funnel-core';
+import { Asset, 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?;
+    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;
+    };
+    type WithGroup = {
+        group: CollectionGroup;
+        collection?: Collection;
+    };
+}

package/dist/core/domain/Collection.js

@@ -0,0 +1,311 @@
+"use strict";
+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._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;