@nascentdigital/funnel-editor 4.4.18

package/dist/core/domain/CollectionFieldProxy.js

@@ -0,0 +1,441 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionFieldProxy = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const rxjs_1 = require("rxjs");
+const repository_1 = require("../repository");
+// model
+class CollectionFieldProxy {
+    constructor(args) {
+        var _a;
+        // initialize instance
+        const eventBus = new funnel_core_1.EventBus();
+        const { collectionSchema, initialData } = args;
+        this.collectionRepository = args.collectionRepository;
+        this.collectionStore = args.collectionStore;
+        this.assetStore = args.assetStore;
+        this.schema = args.schema;
+        this.collectionSchema = collectionSchema;
+        this.language = args.language;
+        this.eventBus = eventBus;
+        this._initialValue = args.initialValue;
+        this._initialData = initialData;
+        this._syncing = false;
+        // initialize name
+        const name = (initialData === null || initialData === void 0 ? void 0 : initialData.name) || '';
+        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 ${collectionSchema.name}.`,
+                hint: 'Please provide a name',
+                semantics: 'short',
+                required: true
+            }),
+            eventBus,
+            initialValue: funnel_core_1.Schema.TextField.Value.toData(name),
+            required: true
+        });
+        // initialize tags
+        const tags = repository_1.TagSerializer.deserializeTags({
+            groups: collectionSchema.tags,
+            tagsData: (_a = initialData === null || initialData === void 0 ? void 0 : initialData.tags) !== null && _a !== void 0 ? _a : []
+        });
+        this._initialTags = new Set(tags);
+        this._tags = new Set(tags);
+        // initialize fields
+        this.fields = Object.entries(collectionSchema.editableFields)
+            .map(([id, schema]) => repository_1.FieldSerializer.deserializeField({
+            id,
+            eventBus,
+            schema,
+            content: initialData === null || initialData === void 0 ? void 0 : initialData.fields[id],
+            snapshot: undefined
+        }));
+        // initial errors
+        this._initialErrors = !this.valid;
+    }
+    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 id() {
+        // throw if it's not a ref
+        const { _initialValue } = this;
+        if (!funnel_core_1.Schema.CollectionField.Value.ForRef.filter(_initialValue)) {
+            throw new funnel_core_1.InvalidOperationError('Cannot access "id" of non-ref Collection');
+        }
+        // return id
+        return _initialValue.id;
+    }
+    get type() {
+        return this.collectionSchema.type;
+    }
+    get assets() {
+        const { assetStore, _initialData } = this;
+        return funnel_core_1.Schema.Collection.Data.filter(_initialData)
+            ? _initialData.files
+            : assetStore.assets;
+    }
+    get collections() {
+        const { collectionStore, _initialData } = this;
+        return funnel_core_1.Schema.Collection.Data.filter(_initialData)
+            ? _initialData.collections
+            : collectionStore.collections;
+    }
+    get groupId() {
+        const { isRef, _initialData } = this;
+        return isRef
+            ? _initialData.groupId
+            : undefined;
+    }
+    get isNew() {
+        return !this._initialValue;
+    }
+    get isRef() {
+        return funnel_core_1.Schema.CollectionField.Value.ForRef.filter(this._initialValue);
+    }
+    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 initialTags() {
+        return this._initialTags;
+    }
+    get tagGroups() {
+        return this.collectionSchema.tags;
+    }
+    get tags() {
+        return this._tags;
+    }
+    addTag(tag) {
+        // skip if page has tag
+        const { _tags } = this;
+        if (_tags.has(tag)) {
+            return;
+        }
+        // add tag
+        _tags.add(tag);
+        // raise event
+        this.raiseEvent('changed');
+    }
+    removeTag(tag) {
+        // skip if tag isn't there
+        const { _tags } = this;
+        if (!_tags.has(tag)) {
+            return;
+        }
+        // add tag
+        _tags.delete(tag);
+        // raise event
+        this.raiseEvent('changed');
+    }
+    get syncing() {
+        return this._syncing;
+    }
+    set syncing(syncing) {
+        this._syncing = syncing;
+        this.raiseEvent('changed');
+    }
+    get valid() {
+        const valid = this.allFields.map(field => ({ id: field.id, valid: field.valid, field }));
+        console.debug('[CollectionFieldProxy/valid] validation: ', valid);
+        return this.allFields.every(field => field.valid);
+    }
+    get initialErrors() {
+        return this._initialErrors;
+    }
+    get modified() {
+        const { allFields, initialTags, _tags } = this;
+        return allFields.some(field => field.modified)
+            || initialTags.symmetricDifference(_tags).size > 0;
+    }
+    get value() {
+        // return reference value (if it's a ref)
+        const { _initialValue } = this;
+        if (funnel_core_1.Schema.CollectionField.Value.ForRef.filter(_initialValue)) {
+            return _initialValue;
+        }
+        // return schema
+        return this.getInlineData();
+    }
+    getInlineData() {
+        // return
+        const { collectionSchema, tags, name, fields } = this;
+        return {
+            type: collectionSchema.type,
+            version: collectionSchema.version,
+            tags: tags.values().map(tag => tag.data).toArray(),
+            name,
+            fields: fields.reduce((fields, { id, value }) => {
+                // add field if it has a value
+                if (value) {
+                    fields[id] = value;
+                }
+                // keep reducing
+                return fields;
+            }, {})
+        };
+    }
+    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': {
+                const { assetStore, groupId } = this;
+                return groupId
+                    ? new funnel_core_1.Schema.CollectionInstanceAssetScope(groupId)
+                    : assetStore.getAssetScope(range);
+            }
+        }
+    }
+    getSearchScope() {
+        const { assetStore, type, groupId } = this;
+        return groupId
+            ? { target: 'collection', type, groupId }
+            : assetStore.getSearchScope();
+    }
+    getAsset(id) {
+        const { assetStore, _initialData } = this;
+        return funnel_core_1.Schema.Collection.Data.filter(_initialData)
+            ? _initialData.files.find(asset => asset.value.id === id)
+            : assetStore.getAsset(id);
+    }
+    addAsset(asset) {
+        // forward if not remote
+        const { assetStore, _initialData } = this;
+        if (!funnel_core_1.Schema.Collection.Data.filter(_initialData)) {
+            return assetStore.addAsset(asset);
+        }
+        // replace asset if it exists
+        const { files } = _initialData;
+        const { id } = asset.value;
+        const assetIndex = files.findIndex(asset => asset.value.id === id);
+        if (assetIndex >= 0) {
+            files[assetIndex] = asset;
+        }
+        // or add asset
+        else {
+            files.push(asset);
+        }
+        // raise event
+        this.raiseEvent('changed');
+    }
+    removeAsset(assetId) {
+        // forward if not remote
+        const { assetStore, _initialData } = this;
+        if (!funnel_core_1.Schema.Collection.Data.filter(_initialData)) {
+            return assetStore.removeAsset(assetId);
+        }
+        // skip if asset isn't there
+        const { files } = _initialData;
+        const assetIndex = files.findIndex(asset => asset.value.id === assetId);
+        if (assetIndex < 0) {
+            return false;
+        }
+        // remove asset
+        files.splice(assetIndex, 1);
+        // raise event
+        this.raiseEvent('changed');
+        // indicate success
+        return true;
+    }
+    getCollection(collectionId) {
+        const { collectionStore, _initialData } = this;
+        return funnel_core_1.Schema.Collection.Data.filter(_initialData)
+            ? _initialData.collections.find(collection => collection.id === collectionId)
+            : collectionStore.getCollection(collectionId);
+    }
+    addCollection(collection) {
+        // forward if not remote
+        const { collectionStore, _initialData } = this;
+        if (!funnel_core_1.Schema.Collection.Data.filter(_initialData)) {
+            return collectionStore.addCollection(collection);
+        }
+        // replace collection if it exists
+        const { collections } = _initialData;
+        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) {
+        // forward if not remote
+        const { collectionStore, _initialData } = this;
+        if (!funnel_core_1.Schema.Collection.Data.filter(_initialData)) {
+            return collectionStore.removeCollection(collectionId);
+        }
+        // skip if collection isn't there
+        const { collections } = _initialData;
+        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;
+    }
+    onSaveStart() {
+        this._savingOn = Date.now();
+    }
+    onSaveComplete() {
+        // reset to values to match save
+        const { _savingOn } = this;
+        if (_savingOn) {
+            // sync data
+            this._initialErrors = !this.valid;
+            this._initialTags = new Set(this._tags);
+        }
+        // clear saving flag
+        delete this._savingOn;
+    }
+    async save(shared = false) {
+        // skip if not sharing
+        const { collectionRepository, collectionStore, collectionSchema, language, name, nameField, fields, _initialData } = this;
+        if (!shared) {
+            return;
+        }
+        // initial data
+        let initialData = undefined;
+        if (_initialData !== undefined) {
+            // shared collection means the initial data should be collection data
+            if (!funnel_core_1.Schema.Collection.Data.filter(_initialData)) {
+                throw new funnel_core_1.IllegalStateError('Local data is not collection data');
+            }
+            // set collection data
+            initialData = _initialData;
+        }
+        // update
+        try {
+            // mark as syncing
+            this.syncing = true;
+            // create base collection if new
+            if (!initialData) {
+                console.debug('[CollectionFieldProxy/save] creating remote instance');
+                // create item (fail if we don't get a collection - shouldn't happen)
+                const { collection: collectionData } = await collectionRepository.editorApi.createCollection({
+                    type: collectionSchema.type,
+                    version: collectionSchema.version,
+                    language,
+                    name,
+                    tags: []
+                });
+                if (!collectionData) {
+                    throw new funnel_core_1.IllegalStateError('Failed to create collection');
+                }
+                // update data
+                initialData = collectionData;
+                // update initial value
+                this._initialValue = {
+                    id: collectionData.id,
+                    type: collectionData.type
+                };
+            }
+            console.debug('[CollectionFieldProxy/save] updating remote instance', initialData);
+            // create update
+            const savables = [];
+            const update = collectionRepository.serializeCollectionUpdate(this, savables);
+            console.debug('[CollectionFieldProxy/save] created update', update);
+            // start all updates
+            this.onSaveStart();
+            savables.forEach(savable => savable.onSaveStart());
+            // update page
+            const { collection: collectionData } = await collectionRepository.editorApi.updateCollection(update);
+            // update collection in store and reset if updated
+            if (collectionData) {
+                // add to collection store
+                collectionStore.addCollection(collectionData);
+                // reset fields
+                nameField.reset(funnel_core_1.Schema.TextField.Value.toData(collectionData.name));
+                fields.forEach(field => {
+                    var _a, _b, _c;
+                    if (field instanceof funnel_core_1.Field) {
+                        field.reset((_a = collectionData.fields[field.id]) !== null && _a !== void 0 ? _a : null);
+                    }
+                    else if (field instanceof funnel_core_1.ObjectField) {
+                        field.reset((_b = collectionData.fields[field.id]) !== null && _b !== void 0 ? _b : null);
+                    }
+                    else {
+                        field.reset((_c = collectionData.fields[field.id]) !== null && _c !== void 0 ? _c : null);
+                    }
+                });
+                // update data
+                initialData = collectionData;
+            }
+            // update collection store with updated local values
+            else {
+                // update data
+                initialData = Object.assign(Object.assign({}, initialData), this.getInlineData());
+                // add to collection store
+                collectionStore.addCollection(initialData);
+            }
+            // complete all updates
+            savables.forEach(savable => savable.onSaveComplete());
+            this.onSaveComplete();
+            // update initial data
+            this._initialData = initialData;
+            // mark changed
+            this.raiseEvent('changed');
+        }
+        // clear syncing status
+        finally {
+            this.syncing = false;
+        }
+    }
+    raiseEvent(type) {
+        this.eventBus.publish(CollectionFieldProxy.Event.create({ type, collection: this }));
+    }
+    static async create(args) {
+        // fetch initial data if it's a ref
+        let initialData;
+        const { collectionRepository, initialValue } = args;
+        if (funnel_core_1.Schema.CollectionField.Value.ForRef.filter(initialValue)) {
+            initialData = await collectionRepository.editorApi.getCollection({ id: initialValue.id, version: 'draft' });
+        }
+        // or use initial value as data
+        else {
+            initialData = initialValue;
+        }
+        // return new model
+        return new CollectionFieldProxy(Object.assign(Object.assign({}, args), { initialData }));
+    }
+}
+exports.CollectionFieldProxy = CollectionFieldProxy;
+// extension
+(function (CollectionFieldProxy) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'CollectionFieldProxy';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return funnel_core_1.EventBus.createEvent(Object.assign({ domain: 'CollectionFieldProxy' }, event));
+        }
+        Event.create = create;
+    })(Event = CollectionFieldProxy.Event || (CollectionFieldProxy.Event = {}));
+})(CollectionFieldProxy || (exports.CollectionFieldProxy = CollectionFieldProxy = {}));

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

@@ -0,0 +1,24 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { Collection } from './Collection';
+export declare class CollectionGroup {
+    readonly template: Schema.Collection;
+    readonly groupId: Schema.Collection.GroupId;
+    readonly brand?: string;
+    readonly name: string;
+    readonly collections: ReadonlyArray<CollectionGroup.CollectionRef>;
+    private _collection?;
+    constructor(args: CollectionGroup.ConstructorArgs);
+    get collection(): Collection | undefined;
+    set collection(collection: Collection | undefined);
+}
+export declare namespace CollectionGroup {
+    type ConstructorArgs = {
+        template: Schema.Collection;
+        groupId: Schema.Collection.GroupId;
+        brand?: string;
+        name: string;
+        collections: CollectionRef[];
+        collection?: Collection;
+    };
+    type CollectionRef = Schema.Collection.Data.AsGroup.Instance;
+}

package/dist/core/domain/CollectionGroup.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionGroup = void 0;
+// model
+class CollectionGroup {
+    constructor(args) {
+        // initialize instance variables
+        this.template = args.template;
+        this.groupId = args.groupId;
+        this.brand = args.brand;
+        this.name = args.name;
+        this.collections = args.collections;
+        this._collection = args.collection;
+    }
+    get collection() {
+        return this._collection;
+    }
+    set collection(collection) {
+        this._collection = collection;
+    }
+}
+exports.CollectionGroup = CollectionGroup;

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

@@ -0,0 +1,33 @@
+import { Language, Schema } from '@nascentdigital/funnel-core';
+import { Collection } from './Collection';
+export declare class CollectionSummary {
+    readonly template: Schema.Collection;
+    readonly brand: string;
+    readonly groupId: Schema.Collection.GroupId;
+    readonly name: string;
+    readonly collections: ReadonlyArray<CollectionSummary.CollectionRef>;
+    readonly languages: ReadonlyArray<Language>;
+    readonly link: CollectionSummary.CollectionRef;
+    readonly status: CollectionSummary.Status;
+    constructor(args: CollectionSummary.ConstructorArgs);
+    get type(): Schema.Collection.Type;
+    hasLanguage(language: Language): boolean;
+    findCollection({ language, fallbackLanguage }: CollectionSummary.GetClosestOptions): CollectionSummary.CollectionRef;
+    getClosestCollectionRef(language: Language, fallback?: Language): Collection.Ref | undefined;
+}
+export declare namespace CollectionSummary {
+    type Status = 'draft' | 'ready' | 'live' | 'changed' | 'empty';
+    type ConstructorArgs = {
+        template: Schema.Collection;
+        brand: string;
+        groupId: Schema.Collection.GroupId;
+        name: string;
+        collections: CollectionRef[];
+        defaultLanguage: Language;
+    };
+    type CollectionRef = Schema.Collection.Data.AsRef;
+    type GetClosestOptions = {
+        language: Language;
+        fallbackLanguage?: Language;
+    };
+}

package/dist/core/domain/CollectionSummary.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionSummary = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class CollectionSummary {
+    constructor(args) {
+        // initialize instance variables
+        const { link, status } = getLinkAndStatus(args.collections, args.defaultLanguage);
+        this.template = args.template;
+        this.brand = args.brand;
+        this.groupId = args.groupId;
+        this.name = link.name;
+        this.collections = args.collections;
+        this.languages = args.collections.map(collection => collection.language);
+        this.link = link;
+        this.status = status;
+    }
+    get type() {
+        return this.template.type;
+    }
+    hasLanguage(language) {
+        return this.collections.some(collection => collection.language === language);
+    }
+    findCollection({ language, fallbackLanguage }) {
+        var _a, _b;
+        const { collections } = this;
+        return (_b = (_a = collections.find(collection => collection.language === language)) !== null && _a !== void 0 ? _a : ((fallbackLanguage && fallbackLanguage !== language) ? collections.find(collection => collection.language === fallbackLanguage) : undefined)) !== null && _b !== void 0 ? _b : collections[0];
+    }
+    getClosestCollectionRef(language, fallback) {
+        var _a, _b;
+        const { template, languages, collections } = this;
+        const [firstLanguage] = languages;
+        const ref = (_b = (_a = collections.find(collection => collection.language === language)) !== null && _a !== void 0 ? _a : (fallback && collections.find(collection => collection.language === fallback))) !== null && _b !== void 0 ? _b : (firstLanguage && collections.find(collection => collection.language === firstLanguage));
+        return ref && Object.assign(Object.assign({}, ref), { template, tags: template.tags.flatMap(tagGroup => tagGroup.parse(ref.tags)) });
+    }
+}
+exports.CollectionSummary = CollectionSummary;
+function getLinkAndStatus(collections, defaultLanguage) {
+    var _a;
+    // skip if empty
+    if (collections.length === 0) {
+        throw new funnel_core_1.ArgumentError('Cannot have CollectionSummary without any items');
+    }
+    // prioritize ready-to-publish
+    let link = collections.find(collection => collection.state === 'draft' && !collection.errors);
+    if (link) {
+        return { link, status: 'ready' };
+    }
+    // then completed drafts
+    link = collections.find(collection => collection.state === 'draft' && collection.publishedOn);
+    if (link) {
+        return { link, status: 'changed' };
+    }
+    // then draft
+    link = collections.find(collection => collection.state === 'draft' && !collection.publishedOn);
+    if (link) {
+        return { link, status: 'draft' };
+    }
+    // otherwise, we're live
+    else {
+        return {
+            link: (_a = collections.find(collection => collection.language === defaultLanguage)) !== null && _a !== void 0 ? _a : collections[0],
+            status: 'live'
+        };
+    }
+}

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

@@ -0,0 +1,40 @@
+import { EventBus, Schema } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { AppState } from '../app';
+import { EditorApiClient } from '../client';
+import { CollectionBrowser } from './CollectionBrowser';
+export declare class Collections {
+    readonly appState: AppState;
+    readonly editorApi: EditorApiClient;
+    readonly schemas: ReadonlyArray<Schema.Collection>;
+    private readonly _eventBus;
+    private _state;
+    private _collections?;
+    private _syncPromise?;
+    private readonly _subscription;
+    constructor(args: Collections.ConstructorArgs);
+    get events$(): Observable<Collections.Event>;
+    get state(): Collections.State;
+    private set state(value);
+    get ready(): boolean;
+    get items(): ReadonlyArray<CollectionBrowser>;
+    getItem(type: Schema.Collection.Type): CollectionBrowser | undefined;
+    sync(): Promise<void>;
+    private raiseEvent;
+    private onCollectionEvent;
+}
+export declare namespace Collections {
+    type State = 'uninitialized' | 'initializing' | 'ready' | 'syncing' | 'error';
+    type ConstructorArgs = {
+        appState: AppState;
+        editorApi: EditorApiClient;
+    };
+    interface Event extends EventBus.Event<'Collections', Event.Type> {
+        collections: Collections;
+    }
+    namespace Event {
+        type Type = 'changed';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}