@nascentdigital/funnel-editor 4.4.18

package/dist/core/domain/Section.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Section = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const ItemBase_1 = require("./ItemBase");
+const SectionBlock_1 = require("./SectionBlock");
+// class
+class Section extends ItemBase_1.ItemBase {
+    constructor(args) {
+        var _a;
+        // construct base
+        super(args);
+        // initialize instance variables
+        this.schema = args.schema;
+        this.availableBlocks = args.availableBlocks;
+        this._initialBlocks = args.blocks;
+        // use existing blocks
+        const blocks = (_a = args.blocks) === null || _a === void 0 ? void 0 : _a.slice();
+        if (blocks) {
+            this._blocks = blocks;
+        }
+        // or force presets
+        else {
+            // find preset in schema (or throw - should never happen)
+            const presets = this.schema.preset;
+            // bind blocks
+            const { availableBlocks } = this;
+            this._blocks = presets
+                .map(key => availableBlocks.find(block => block.key === key))
+                .filter(funnel_core_1.Value.isDefined)
+                .map(SectionBlock_1.SectionBlock.for);
+            // mark as activated
+            this.activated = true;
+        }
+    }
+    get identifier() {
+        return this.key;
+    }
+    get state() {
+        return 'valid';
+    }
+    get name() {
+        return this.schema.name;
+    }
+    get initialBlocks() {
+        return this._initialBlocks;
+    }
+    get blocks() {
+        var _a;
+        return (_a = this._blocks) !== null && _a !== void 0 ? _a : [];
+    }
+    get modified() {
+        const { initialBlocks = [], _blocks = [] } = this;
+        return initialBlocks.length !== _blocks.length
+            || initialBlocks.some((block, index) => _blocks[index] !== block)
+            || _blocks.some(block => block.modified);
+    }
+    get valid() {
+        // TODO: validate against section level rules
+        return this.blocks.every(block => block.valid);
+    }
+    get changes() {
+        return {
+            section: this,
+            blocks: this.blocks.filter(block => block.changes.fields.length > 0)
+        };
+    }
+    get errors() {
+        return {
+            section: this,
+            blocks: this.blocks.filter(block => !block.valid)
+        };
+    }
+    bind(parentContext) {
+        // invoke base
+        super.bind(parentContext);
+        // bind children
+        this._blocks.forEach(block => block.bind({ parent: this, area: parentContext.area }));
+    }
+    addBlock(identifier) {
+        // throw if block isn't available
+        const blockTemplate = this.availableBlocks.find(block => block.identifier === identifier);
+        if (!blockTemplate) {
+            throw new funnel_core_1.ArgumentError(`Unable to find block matching "${identifier}"`);
+        }
+        // create new section block
+        const block = SectionBlock_1.SectionBlock.for(blockTemplate);
+        this._blocks.push(block);
+        this._modifiedOn = Date.now();
+        // bind block
+        block.bind(this);
+        // raise change
+        this.raiseEvent('changed');
+        // return block
+        return block;
+    }
+    deleteBlock(id) {
+        // skip if block isn't found
+        const { _blocks } = this;
+        const blockIndex = _blocks.findIndex(block => block.id === id);
+        if (blockIndex < 0) {
+            return undefined;
+        }
+        // remove block
+        _blocks.splice(blockIndex, 1);
+        this._modifiedOn = Date.now();
+        // raise change (persists removal)
+        this.raiseEvent('changed');
+    }
+    moveBlock(blockId, newIndex) {
+        // throw if there are no block (shouldn't happen)
+        const oldBlocks = this._blocks;
+        if (!oldBlocks) {
+            throw new funnel_core_1.InvalidOperationError('Cannot move blocks when there are none');
+        }
+        // or throw if block doesn't exist
+        const oldIndex = oldBlocks.findIndex(block => block.id === blockId);
+        if (oldIndex < 0) {
+            throw new funnel_core_1.InvalidOperationError(`Attempt to re-order block outside of set: ${blockId}`);
+        }
+        // or skip if index is unchanged
+        else if (oldIndex === newIndex) {
+            return;
+        }
+        // create new blocks
+        const newBlocks = oldBlocks.slice();
+        // remove item from old index
+        const [block] = newBlocks.splice(oldIndex, 1);
+        // move to new index (deleting first takes care of positional issues)
+        newBlocks.splice(newIndex, 0, block);
+        // establish new blocks array
+        this._blocks = newBlocks;
+        this._modifiedOn = Date.now();
+        // raise change
+        this.raiseEvent('changed');
+        // return moved block
+        return block;
+    }
+    repair() {
+        // repair all blocks
+        this._blocks.forEach(block => block.repair());
+    }
+    onSaveStart() {
+        this._savingOn = Date.now();
+    }
+    onSaveComplete() {
+        // reset to initial value if not modified or if save is newer
+        const { _modifiedOn, _savingOn } = this;
+        if (_savingOn && (!_modifiedOn || _savingOn >= _modifiedOn)) {
+            this._initialBlocks = this._blocks.slice();
+        }
+        // clear saving flag
+        delete this._savingOn;
+    }
+}
+exports.Section = Section;

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

@@ -0,0 +1,32 @@
+import { FieldModel, Schema } from '@nascentdigital/funnel-core';
+import { Tagged } from 'type-fest';
+import { Block } from './Block';
+import { BlockConfiguration } from './BlockConfiguration';
+import { ItemBase } from './ItemBase';
+export declare class SectionBlock<TBlock extends Schema.Block = Schema.Block> extends ItemBase<SectionBlock<TBlock>> {
+    readonly id: SectionBlock.Id;
+    readonly block: Block<TBlock>;
+    constructor(args: SectionBlock.ConstructorArgs<TBlock>);
+    get schema(): TBlock;
+    get identifier(): string;
+    get name(): string;
+    get config(): ReadonlyArray<FieldModel>;
+    get fields(): ReadonlyArray<FieldModel>;
+    get state(): "undefined" | "invalid" | "valid";
+    get value(): Schema.Section.Data.ForBlock;
+    get modified(): boolean;
+    get changes(): Block.Changes;
+    get valid(): boolean;
+    get errors(): Block.Errors;
+    getConfiguration(): BlockConfiguration;
+    bind(parentContext: ItemBase.ParentContext): void;
+    repair(): void;
+    static for(block: Block): SectionBlock<Schema.Block<string, any, any>>;
+}
+export declare namespace SectionBlock {
+    type Id = Tagged<string, 'SectionBlock.Id'>;
+    type ConstructorArgs<TBlock extends Schema.Block = Schema.Block> = ItemBase.ConstructorArgs & {
+        id: string;
+        block: Block<TBlock>;
+    };
+}

package/dist/core/domain/SectionBlock.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SectionBlock = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const BlockConfiguration_1 = require("./BlockConfiguration");
+const ItemBase_1 = require("./ItemBase");
+// class
+class SectionBlock extends ItemBase_1.ItemBase {
+    constructor(args) {
+        // construct base
+        super(Object.assign(Object.assign({}, args), { required: true }));
+        // initialize instance variables
+        this.id = args.id;
+        this.block = args.block;
+    }
+    get schema() {
+        return this.block.schema;
+    }
+    get identifier() {
+        return `${this.key}.${this.id}`;
+    }
+    get name() {
+        return this.block.name;
+    }
+    get config() {
+        return this.block.config;
+    }
+    get fields() {
+        return this.block.fields;
+    }
+    get state() {
+        return this.block.state;
+    }
+    get value() {
+        const { id, block } = this;
+        return Object.assign({ section: {
+                id,
+                block: block.key
+            } }, block.value);
+    }
+    get modified() {
+        return this.block.modified;
+    }
+    get changes() {
+        return this.block.changes;
+    }
+    get valid() {
+        return this.block.valid;
+    }
+    get errors() {
+        return this.block.errors;
+    }
+    getConfiguration() {
+        return new BlockConfiguration_1.BlockConfiguration({ block: this, assetStore: this.root });
+    }
+    bind(parentContext) {
+        // bind base
+        super.bind(parentContext);
+        // bind block
+        this.block.bind(parentContext);
+    }
+    repair() {
+        // repair all blocks
+        this.block.repair();
+    }
+    static for(block) {
+        return new SectionBlock({
+            id: funnel_core_1.Value.uuid(),
+            key: block.key,
+            eventBus: block.eventBus,
+            block: block.clone(true),
+            required: block.required,
+            exists: true
+        });
+    }
+}
+exports.SectionBlock = SectionBlock;

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

@@ -0,0 +1,52 @@
+import { BrandConfig, EventBus, Language, RegionsConfig, Schema } from '@nascentdigital/funnel-core';
+import { Observable } from 'rxjs';
+import { AppState } from '../app';
+import { EditorApiClient } from '../client';
+import { PageOverview } from './PageOverview';
+import { Pages } from './Pages';
+export declare class Site {
+    readonly templates: Schema.Site.Pages;
+    readonly collections: ReadonlyArray<Schema.Collection>;
+    readonly brand: BrandConfig.WithId;
+    readonly region: RegionsConfig.RegionConfig.WithId;
+    readonly appState: AppState;
+    readonly editorApi: EditorApiClient;
+    private readonly _eventBus;
+    private _state;
+    private _overviews;
+    private readonly _pages;
+    private readonly _pagesToSync;
+    private _syncPromise?;
+    private readonly _subscription;
+    constructor({ appState, editorApi, region }: Site.ConstructorArgs);
+    get events$(): Observable<Site.Event>;
+    get state(): Site.State;
+    private set state(value);
+    get ready(): boolean;
+    get defaultLanguage(): Language;
+    get overviews(): readonly PageOverview[];
+    hasPageSchema(type: Schema.Page.Type): boolean;
+    getPageSchema(type: Schema.Page.Type): Schema.Page;
+    getCollectionSchema(type: Schema.Collection.Type): Schema.Collection | undefined;
+    getPages(pageType: Schema.Page.Type, tags?: ReadonlyArray<Schema.Tag>): Pages;
+    getClosestLanguage(options: ReadonlyArray<Language | Language.Prop>): Language;
+    sync(): Promise<void>;
+    private raiseEvent;
+    private onPageEvent;
+}
+export declare namespace Site {
+    type State = 'uninitialized' | 'initializing' | 'ready' | 'syncing' | 'error';
+    type ConstructorArgs = {
+        appState: AppState;
+        editorApi: EditorApiClient;
+        region: string;
+    };
+    interface Event extends EventBus.Event<'Site', Event.Type> {
+        site: Site;
+    }
+    namespace Event {
+        type Type = 'changed';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}

package/dist/core/domain/Site.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Site = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const Pages_1 = require("./Pages");
+// model
+class Site {
+    constructor({ appState, editorApi, region }) {
+        // initialize instance variables
+        const site = funnel_core_1.Schema.Site.current();
+        const brand = funnel_core_1.AppConfig.brand();
+        const brandConfig = funnel_core_1.AppConfig.brandConfig();
+        this.templates = site.regions[region];
+        this.collections = site.collections;
+        this.brand = Object.assign(Object.assign({}, brandConfig), { id: brand });
+        this.region = Object.assign(Object.assign({}, brandConfig.regionalization.regions[region]), { id: region });
+        this.appState = appState;
+        this.editorApi = editorApi;
+        this._eventBus = new funnel_core_1.EventBus();
+        this._state = 'uninitialized';
+        this._overviews = [];
+        this._pages = new Map();
+        this._pagesToSync = new Set();
+        // start initial loading of data
+        this.sync().catch(console.error);
+        // listen to app state for page changes
+        this._subscription = this.appState.pageEvents$.subscribe(e => this.onPageEvent(e));
+    }
+    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 defaultLanguage() {
+        var _a;
+        const { region } = this;
+        return (_a = region.defaultLanguage) !== null && _a !== void 0 ? _a : region.languages[0];
+    }
+    get overviews() {
+        return this._overviews;
+    }
+    hasPageSchema(type) {
+        return this.templates[type] !== undefined;
+    }
+    getPageSchema(type) {
+        // resolve template (or throw)
+        const template = this.templates[type];
+        if (!template) {
+            throw new funnel_core_1.IllegalStateError(`Unable to resolve template "${type}"`);
+        }
+        // return template
+        return template;
+    }
+    getCollectionSchema(type) {
+        return this.collections.find(schema => schema.type === type);
+    }
+    getPages(pageType, tags = []) {
+        // don't cache if there are tags
+        if (tags.length > 0) {
+            return new Pages_1.Pages({ site: this, pageType });
+        }
+        // resolve existing collection (or create one)
+        const { _pages, _pagesToSync } = this;
+        let collection = _pages.get(pageType);
+        if (!collection) {
+            console.debug('[Site/getPages] getting new pages for ', pageType);
+            // create collection
+            collection = new Pages_1.Pages({ site: this, pageType });
+            // cache it
+            _pages.set(pageType, collection);
+        }
+        // or sync if required (clears collection)
+        else if (_pagesToSync.delete(pageType)) {
+            console.debug('[Site/getPages] refreshing pages for ', pageType);
+            collection.sync().catch(console.error);
+        }
+        // return collection
+        return collection;
+    }
+    getClosestLanguage(options) {
+        // extract languages from options
+        const languages = options.map(option => typeof option === 'string' ? option : option.language);
+        // determine default/fallback
+        const { defaultLanguage } = this;
+        const fallbackLanguage = languages.length > 0
+            ? languages[0]
+            : defaultLanguage;
+        // return default if it's an option or use fallback
+        return languages.includes(defaultLanguage)
+            ? defaultLanguage
+            : fallbackLanguage;
+    }
+    async sync() {
+        // return existing promise if any
+        if (this._syncPromise) {
+            return this._syncPromise;
+        }
+        // create new sync
+        const onSync = async () => {
+            // get site map
+            try {
+                // mark as syncing
+                this.state = this._state === 'uninitialized'
+                    ? 'initializing'
+                    : 'syncing';
+                // load overview
+                this._overviews = await this.editorApi.getPagesOverview({ region: this.region.id, version: 'draft' });
+                // mark as ready
+                this.state = 'ready';
+            }
+            // TODO: handle error
+            catch (e) {
+                console.error('[Site/sync] refresh failed', e);
+                // move to error state
+                this.state = 'error';
+            }
+            // clear sync promise when complete
+            finally {
+                delete this._syncPromise;
+            }
+        };
+        // start sync (and capture it)
+        this._syncPromise = onSync();
+        // wait until sync is complete
+        await this._syncPromise;
+    }
+    raiseEvent(type) {
+        this._eventBus.publish(Site.Event.create({ type, site: this }));
+    }
+    onPageEvent(e) {
+        console.debug('[Site/onPageEvent] handling page event', e);
+        // add sync if the item is dynamic
+        const { page } = e;
+        if (page.template.variant === 'dynamic') {
+            this._pagesToSync.add(page.type);
+        }
+    }
+}
+exports.Site = Site;
+// extension
+(function (Site) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'Page';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return funnel_core_1.EventBus.createEvent(Object.assign({ domain: 'Site' }, event));
+        }
+        Event.create = create;
+    })(Event = Site.Event || (Site.Event = {}));
+})(Site || (exports.Site = Site = {}));

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

@@ -0,0 +1,7 @@
+import { Field as CoreField, ObjectField as CoreObjectField, Schema } from '@nascentdigital/funnel-core';
+export declare namespace TranslateSchema {
+    type Field<T extends Schema.Field.Type> = T extends Schema.TextField ? CoreField<Schema.TextField> : T extends Schema.EnumField ? CoreField<Schema.EnumField> : T extends Schema.BooleanField ? CoreField<Schema.BooleanField> : T extends Schema.DateField ? CoreField<Schema.DateField> : T extends Schema.TimestampField ? CoreField<Schema.TimestampField> : T extends Schema.LinkField ? CoreField<Schema.LinkField> : T extends Schema.AssetField ? CoreField<Schema.AssetField> : T extends Schema.CollectionField ? CoreField<Schema.CollectionField> : T extends Schema.PageField ? CoreField<Schema.PageField> : T extends Schema.ObjectField<infer C> ? CoreObjectField : never;
+    type Fields<TFields extends Record<string, Schema.Optional.Maybe<Schema.Field.Type>>> = {
+        [TKey in keyof TFields]: Field<Schema.Optional.InnerType<TFields[TKey]>>;
+    };
+}

package/dist/core/domain/TranslateSchema.js

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

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

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

package/dist/core/domain/UserBrowser.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserBrowser = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const funnel_cms_1 = require("@nascentdigital/funnel-cms");
+// class
+class UserBrowser {
+    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 users() {
+        var _a;
+        return (_a = this._users) !== null && _a !== void 0 ? _a : [];
+    }
+    get owners() {
+        return this.users.filter(user => user.role.id === 'owner');
+    }
+    get admins() {
+        return this.users.filter(user => user.role.id === 'admin');
+    }
+    get editors() {
+        return this.users.filter(user => user.role.id === 'editor');
+    }
+    get viewers() {
+        return this.users.filter(user => user.role.id === 'viewer');
+    }
+    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 users
+                const { editorApi } = this;
+                const usersData = await editorApi.getUsers();
+                this._users = usersData
+                    .map(userData => new funnel_cms_1.User(userData))
+                    .sort((lhs, rhs) => lhs.compareTo(rhs));
+                // mark as ready
+                this.state = 'ready';
+            }
+            // TODO: handle error
+            catch (e) {
+                console.error('[UserBrowser/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(UserBrowser.Event.create({ type, browser: this }));
+    }
+}
+exports.UserBrowser = UserBrowser;
+// extension
+(function (UserBrowser) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'UserBrowser';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return funnel_core_1.EventBus.createEvent(Object.assign({ domain: 'UserBrowser' }, event));
+        }
+        Event.create = create;
+    })(Event = UserBrowser.Event || (UserBrowser.Event = {}));
+})(UserBrowser || (exports.UserBrowser = UserBrowser = {}));

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

@@ -0,0 +1,6 @@
+import { Schema } from '@nascentdigital/funnel-core';
+export declare namespace UserValidation {
+    const EmailField: Schema.TextField;
+    const UsernameField: Schema.TextField;
+    const PasswordField: Schema.TextField;
+}

package/dist/core/domain/UserValidation.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserValidation = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// validation
+var UserValidation;
+(function (UserValidation) {
+    // validation
+    UserValidation.EmailField = funnel_core_1.Schema.Field.email({
+        name: 'Email'
+    });
+    UserValidation.UsernameField = funnel_core_1.Schema.Field.slug({
+        name: 'Username',
+        minLength: 3,
+        maxLength: 30
+    });
+    UserValidation.PasswordField = funnel_core_1.Schema.Field.password({
+        name: 'Password',
+        description: 'Make sure your password is between 8-32 character and includes a combination of symbols, numbers, and upper/lower case letters.',
+        hint: 'Enter password',
+        minLength: 8,
+        maxLength: 32
+    });
+})(UserValidation || (exports.UserValidation = UserValidation = {}));