@nascentdigital/funnel-editor 4.4.18

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

@@ -0,0 +1,42 @@
+import { BlockLayout, EventBus, FieldModel } from '@nascentdigital/funnel-core';
+import { Block } from './Block';
+import { IAssetStore } from './IAssetStore';
+import { SectionBlock } from './SectionBlock';
+export declare class BlockConfiguration {
+    readonly eventBus: EventBus;
+    readonly assetStore: IAssetStore;
+    readonly sectionBlock?: SectionBlock;
+    readonly block: Block;
+    readonly fields: ReadonlyArray<FieldModel.Config>;
+    private _editableFields;
+    private _layout?;
+    private _defaultConfig?;
+    private _isConfigInDefault?;
+    constructor({ block: blockOrSectionBlock, assetStore }: BlockConfiguration.ConstructorArgs);
+    get editableFields(): ReadonlyArray<FieldModel.Config>;
+    set editableFields(fields: ReadonlyArray<FieldModel.Config>);
+    get layout(): BlockLayout | undefined;
+    get events$(): import("rxjs").Observable<EventBus.Event<string, string>>;
+    get valid(): boolean;
+    get modified(): boolean;
+    getField(fieldId: string): FieldModel;
+    save(): void;
+    reset(): void;
+    get isConfigInDefault(): boolean | undefined;
+    sync(): void;
+    private raiseEvent;
+}
+export declare namespace BlockConfiguration {
+    type ConstructorArgs = {
+        assetStore: IAssetStore;
+        block: Block | SectionBlock;
+    };
+    interface Event extends EventBus.Event<'BlockConfiguration', Event.Type> {
+        configuration: BlockConfiguration;
+    }
+    namespace Event {
+        type Type = 'changed' | 'modified';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}

package/dist/core/domain/BlockConfiguration.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockConfiguration = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const rxjs_1 = require("rxjs");
+const SectionBlock_1 = require("./SectionBlock");
+// model
+class BlockConfiguration {
+    constructor({ block: blockOrSectionBlock, assetStore }) {
+        // initialize core fields
+        const eventBus = new funnel_core_1.EventBus();
+        this.eventBus = eventBus;
+        this.assetStore = assetStore;
+        const fields = [];
+        this.fields = fields;
+        this._editableFields = fields;
+        this._isConfigInDefault = false;
+        // initialize section block
+        if (blockOrSectionBlock instanceof SectionBlock_1.SectionBlock) {
+            // capture parents
+            this.sectionBlock = blockOrSectionBlock;
+            this.block = blockOrSectionBlock.block;
+            // add name
+            const nameField = blockOrSectionBlock.block.nameField.clone({ eventBus });
+            nameField.reset(funnel_core_1.Schema.TextField.Value.toData(blockOrSectionBlock.block.name));
+            fields.push(nameField);
+        }
+        // or regular block
+        else {
+            // capture parent
+            this.block = blockOrSectionBlock;
+        }
+        // add fields
+        this.block.config.forEach(field => fields.push(field.clone({ eventBus })));
+        // sync
+        this.sync();
+        // force sync if a field is modified
+        this.eventBus.events$
+            .pipe((0, rxjs_1.filter)(event => funnel_core_1.Field.Event.filter(event) && event.type === 'changed'))
+            .subscribe(() => this.sync());
+    }
+    get editableFields() {
+        return this._editableFields;
+    }
+    set editableFields(fields) {
+        this._editableFields = fields;
+        this.raiseEvent('changed');
+    }
+    get layout() {
+        return this._layout;
+    }
+    get events$() {
+        return this.eventBus.events$;
+    }
+    get valid() {
+        return this.editableFields.every(field => field.valid);
+    }
+    get modified() {
+        return !funnel_core_1.Value.equals(this.fields.filter(field => field.hasValue).map(field => field.value), this.editableFields.map(field => field.value));
+    }
+    getField(fieldId) {
+        // return field or throw
+        const field = this.fields.find(field => field.id === fieldId);
+        if (!field) {
+            throw new funnel_core_1.IllegalStateError(`Unable to resolve field ${this.block.name}/${fieldId}`);
+        }
+        // return field
+        return field;
+    }
+    save() {
+        // save each modified field
+        const { sectionBlock, block, editableFields } = this;
+        editableFields.forEach(field => {
+            // skip if not modified / valid
+            const { id, modified, valid } = field;
+            // handle name change field
+            if (id === block.nameField.id) {
+                // return if not modified or not valid
+                if (!modified || !valid) {
+                    return;
+                }
+                // throw if it's not a section (should never happen)
+                if (!sectionBlock || block.nameField.schema.type !== field.schema.type) {
+                    throw new funnel_core_1.IllegalStateError('Attempt to save nameField in regular Block');
+                }
+                // or sync upwards
+                else {
+                    block.nameField.value = field.value;
+                }
+            }
+            // otherwise, handle other fields
+            else {
+                // throw if field doesn't exist (should never happen)
+                const originalField = block.getConfig(field.id);
+                if (!originalField) {
+                    throw new funnel_core_1.IllegalStateError(`Unable to find field in block: ${field.id}`);
+                }
+                // skip if the original field had a value and is now not modified or is not valid
+                if ((originalField.hasValue && !modified) || !valid) {
+                    return;
+                }
+                // save the field, if the checks pass
+                else {
+                    // or throw if type doesn't match
+                    if (originalField.schema.type !== field.schema.type) {
+                        throw new funnel_core_1.IllegalStateError(`Block field mismatch for "${field.id}" (${originalField.schema.type} vs ${field.schema.type})`);
+                    }
+                    // or sync upwards
+                    else {
+                        originalField.value = field.value;
+                    }
+                }
+            }
+        });
+        // clear any removed (i.e. non-editable) fields in the original block
+        block.config.forEach(originalField => {
+            // remove original field if it has a value, but isn't editable
+            if (originalField.hasValue && !editableFields.some(editableField => editableField.id === originalField.id)) {
+                // ensure field is optional
+                if (originalField.required) {
+                    throw new funnel_core_1.InvalidOperationError(`Config schema for ${originalField.id} has been removed but isn't optional()`);
+                }
+                // and then opt-out
+                originalField.optOut();
+            }
+        });
+    }
+    reset() {
+        // set the editable fields to their default values
+        this.editableFields.forEach(field => {
+            // throw if default config is not set
+            if (!this._defaultConfig) {
+                throw new funnel_core_1.IllegalStateError('Default config not available to perform reset');
+            }
+            // extract default value
+            const defaultValue = this._defaultConfig[field.id];
+            // throw if value is not available
+            if (!defaultValue) {
+                throw new funnel_core_1.IllegalStateError(`Default value not available for field: ${field.id}`);
+            }
+            // set the default value
+            field.coerceValue(defaultValue);
+        });
+        // sync with the values
+        this.sync();
+    }
+    get isConfigInDefault() {
+        return this._isConfigInDefault;
+    }
+    sync() {
+        // recompute the editable fields
+        const { assetStore, block, fields, editableFields } = this;
+        const configData = editableFields.reduce((data, field) => {
+            data[field.id] = field.value;
+            // keep reducing
+            return data;
+        }, {});
+        const fieldData = block.fields.reduce((data, field) => {
+            // link assets
+            const fieldValue = field.value;
+            if ((fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.type) === 'asset') {
+                const assetData = funnel_core_1.Schema.AssetField.Value.fromData(fieldValue);
+                const asset = (assetData === null || assetData === void 0 ? void 0 : assetData.id)
+                    ? assetStore.getAsset(assetData === null || assetData === void 0 ? void 0 : assetData.id)
+                    : undefined;
+                data[field.id] = assetData && asset
+                    ? funnel_core_1.Schema.AssetField.LinkedValue.toData(funnel_core_1.Schema.AssetField.Value.toLinked(assetData, asset))
+                    : fieldValue;
+            }
+            else {
+                data[field.id] = field.value;
+            }
+            // keep reducing
+            return data;
+        }, {});
+        // get customized schema (if there are effects)
+        const blockSchema = block.schema;
+        const { getConfig, getLayout } = blockSchema;
+        const { updatedConfig = configData, updatedConfigSchema = blockSchema.config, defaultConfig = {} } = getConfig
+            ? getConfig({ configSchema: blockSchema.config, config: configData, fields: fieldData })
+            : {};
+        // create new config fields
+        const configFields = fields
+            // drop fields not in config
+            .filter(field => (field.id in updatedConfigSchema && updatedConfigSchema[field.id]) || field.id === block.nameField.id)
+            // create new field and swizzle the value if the option is not available
+            .map(field => {
+            // clone field
+            const updatedSchema = updatedConfigSchema[field.id];
+            const updatedValue = updatedConfig[field.id];
+            const clone = field.clone({ schema: updatedSchema === null || updatedSchema === void 0 ? void 0 : updatedSchema.require() });
+            // if not a name field, throw if type doesn't match
+            if (updatedSchema && clone.id !== block.nameField.id) {
+                // fail if value type does not match with schema
+                if (updatedValue && updatedValue.type !== updatedSchema.type) {
+                    console.error('[BlockConfiguration] updated value doesn\'t match schema type', { updatedSchema, updatedValue });
+                    throw new funnel_core_1.IllegalStateError(`Expected schema value of type "${updatedSchema.type}" but found "${updatedValue.type}"`);
+                }
+            }
+            // update value
+            clone.coerceValue(updatedValue);
+            // return cloned field
+            return clone;
+        });
+        // resolve layouts
+        this._layout = getLayout
+            ? getLayout({ config: configData, fields: fieldData })
+            : undefined;
+        // assign to editable fields (raised event)
+        this.editableFields = configFields;
+        // compute the default config
+        this._defaultConfig = configFields.reduce((data, field) => {
+            if (defaultConfig[field.id]) {
+                return Object.assign(Object.assign({}, data), { [field.id]: defaultConfig[field.id] });
+            }
+            return data;
+        }, {});
+        // determine if the values of the editable fields are same as default
+        this._isConfigInDefault = funnel_core_1.Value.equals(Object.values(this._defaultConfig), this.editableFields.map(field => field.value));
+    }
+    raiseEvent(type) {
+        this.eventBus.publish(BlockConfiguration.Event.create({ type, configuration: this }));
+    }
+}
+exports.BlockConfiguration = BlockConfiguration;
+// extension
+(function (BlockConfiguration) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'BlockConfiguration';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return funnel_core_1.EventBus.createEvent(Object.assign({ domain: 'BlockConfiguration' }, event));
+        }
+        Event.create = create;
+    })(Event = BlockConfiguration.Event || (BlockConfiguration.Event = {}));
+})(BlockConfiguration || (exports.BlockConfiguration = BlockConfiguration = {}));

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

@@ -0,0 +1,33 @@
+import { EventBus, Schema } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { EditorApiClient } from '../client';
+export declare class ChangeSetBrowser {
+    readonly editorApi: EditorApiClient;
+    private readonly _eventBus;
+    private _state;
+    private _items?;
+    private _syncPromise?;
+    constructor(args: ChangeSetBrowser.ConstructorArgs);
+    get events$(): Observable<ChangeSetBrowser.Event>;
+    get state(): ChangeSetBrowser.State;
+    private set state(value);
+    get ready(): boolean;
+    get items(): readonly Schema.ChangeSet.Data.Grouped[];
+    sync(): Promise<void>;
+    private raiseEvent;
+}
+export declare namespace ChangeSetBrowser {
+    type State = 'uninitialized' | 'initializing' | 'ready' | 'syncing' | 'error';
+    type Filter = Schema.ChangeSet.GroupId | 'default';
+    type ConstructorArgs = {
+        editorApi: EditorApiClient;
+    };
+    interface Event extends EventBus.Event<'ChangeSetBrowser', Event.Type> {
+        browser: ChangeSetBrowser;
+    }
+    namespace Event {
+        type Type = 'changed';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}

package/dist/core/domain/ChangeSetBrowser.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeSetBrowser = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class ChangeSetBrowser {
+    constructor(args) {
+        // initialize instance variables
+        this.editorApi = args.editorApi;
+        this._eventBus = new funnel_core_1.EventBus();
+        this._state = 'uninitialized';
+    }
+    get events$() {
+        return this._eventBus.events$;
+    }
+    get state() {
+        return this._state;
+    }
+    set state(state) {
+        // ignore if unchanged
+        if (this._state === state) {
+            return;
+        }
+        // update state
+        this._state = state;
+        // raise event
+        this.raiseEvent('changed');
+    }
+    get ready() {
+        return this._state === 'ready';
+    }
+    get items() {
+        var _a;
+        return (_a = this._items) !== null && _a !== void 0 ? _a : [];
+    }
+    async sync() {
+        // return in-flight sync (if any)
+        if (this._syncPromise) {
+            return this._syncPromise;
+        }
+        // create sync
+        const onSync = async () => {
+            // get site map
+            try {
+                // mark as syncing
+                this.state = this._state === 'uninitialized'
+                    ? 'initializing'
+                    : 'syncing';
+                // load changesets
+                const { editorApi } = this;
+                this._items = await editorApi.listChangeSetGroups();
+                // mark as ready
+                this.state = 'ready';
+            }
+            // TODO: handle error
+            catch (e) {
+                console.error('[ChangeSetBrowser/sync] refresh failed', e);
+                // move to error state
+                this.state = 'error';
+            }
+            // clear sync when complete
+            finally {
+                delete this._syncPromise;
+            }
+        };
+        // start sync (and capture)
+        this._syncPromise = onSync();
+        // return sync
+        return this._syncPromise;
+    }
+    raiseEvent(type) {
+        this._eventBus.publish(ChangeSetBrowser.Event.create({ type, browser: this }));
+    }
+}
+exports.ChangeSetBrowser = ChangeSetBrowser;
+// extension
+(function (ChangeSetBrowser) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'ChangeSetBrowser';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return funnel_core_1.EventBus.createEvent(Object.assign({ domain: 'ChangeSetBrowser' }, event));
+        }
+        Event.create = create;
+    })(Event = ChangeSetBrowser.Event || (ChangeSetBrowser.Event = {}));
+})(ChangeSetBrowser || (exports.ChangeSetBrowser = ChangeSetBrowser = {}));

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

@@ -0,0 +1,125 @@
+import { AssetClient, CollectionClient } from '@nascentdigital/funnel-cms';
+import { EventBus, Field, FieldList, FieldModel, Language, ObjectField, Schema } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { Asset } from './Asset';
+import { IAssetStore } from './IAssetStore';
+import { ICollectionStore } from './ICollectionStore';
+import { IPageRefStore } from './IPageRefStore';
+import { ITagged } from './ITagged';
+import { Item } from './Item';
+import { Page } from './Page';
+export declare class Collection implements IAssetStore, ICollectionStore, IPageRefStore, ITagged {
+    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>;
+    private _initialTags;
+    readonly pageIds: Schema.Page.Id[];
+    private readonly _tags;
+    readonly fields: ReadonlyArray<FieldModel>;
+    private readonly _assets;
+    private readonly _collections;
+    private readonly _pages;
+    private _state;
+    private _initialErrors;
+    private _changeSetId?;
+    readonly snapshotId?: Schema.CollectionSnapshot.Id;
+    readonly snapshot?: Schema.CollectionSnapshot;
+    readonly createdOn: number;
+    private _updatedOn;
+    readonly publishedOn?: number;
+    private _syncing;
+    private _modifiedOn?;
+    private _savingOn?;
+    constructor(args: Collection.ConstructorArgs);
+    get asRef(): Collection.Ref;
+    get events$(): Observable<Collection.Events>;
+    get stable$(): Observable<boolean>;
+    get state(): Schema.Page.State;
+    private set state(value);
+    get assets(): ReadonlyArray<Asset>;
+    get collections(): ReadonlyArray<Schema.Collection.Data.AsLink>;
+    get syncing(): boolean;
+    set syncing(syncing: boolean);
+    get type(): Schema.Collection.Type;
+    get allFields(): FieldModel[];
+    get name(): string;
+    set name(name: string);
+    get initialTags(): ReadonlySet<Schema.Tag<string, string>>;
+    get tagGroups(): ReadonlyArray<Schema.TagGroup>;
+    get tags(): ReadonlySet<Schema.Tag>;
+    addTag(tag: Schema.Tag): void;
+    removeTag(tag: Schema.Tag): void;
+    get published(): boolean;
+    get updatedOn(): number;
+    get changeSetId(): Schema.ChangeSet.Id | undefined;
+    get valid(): boolean;
+    get modified(): boolean;
+    get changes(): Collection.Changes;
+    get initialErrors(): boolean;
+    get errors(): Collection.Errors;
+    getField(fieldId: string): FieldModel;
+    getTextField(fieldId: string): Field<Schema.TextField> | undefined;
+    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): Page.Ref | undefined;
+    addPageRef(page: Page.Ref): void;
+    removePageRef(pageId: string): boolean;
+    onSaveStart(): void;
+    onSaveComplete(updatedOn: number, changeSetId: Schema.ChangeSet.Id): 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 Summary = CollectionClient.GetItems.Item;
+    type Ref = Pick<ConstructorArgs, 'id' | 'groupId' | 'brand' | 'template' | 'language' | 'version' | 'name' | 'tags' | 'state' | 'errors' | 'changeSetId' | 'snapshotId' | 'createdOn' | 'updatedOn' | 'publishedOn'>;
+    type Changes = {
+        collection: Collection;
+        fields: Array<FieldModel>;
+    };
+    type Errors = {
+        collection: Collection;
+        fields: Array<FieldModel>;
+    };
+    type Events = Event | Item.Event | Field.Event | ObjectField.Event | FieldList.Event;
+    interface Event extends EventBus.Event<'Collection', Event.Type> {
+        collection: Collection;
+    }
+    namespace Event {
+        type Type = 'changed' | 'modified';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}