@nascentdigital/funnel-editor 4.4.18

package/dist/core/repository/PageRepository.js

@@ -0,0 +1,462 @@
+"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.PageRepository = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const domain_1 = require("../domain");
+const PageSerializer_1 = require("./PageSerializer");
+// class
+class PageRepository {
+    constructor(editorApi) {
+        this.editorApi = editorApi;
+    }
+    async search(args) {
+        // query pages
+        const { template, region } = args, query = __rest(args, ["template", "region"]);
+        const _a = await this.editorApi.searchPages(Object.assign(Object.assign({}, query), { version: 'draft', brand: funnel_core_1.AppConfig.brand(), region, type: template.type })), { items } = _a, pagination = __rest(_a, ["items"]);
+        // return result
+        return Object.assign({ items: items.map((_a) => {
+                var _b;
+                var { tags } = _a, item = __rest(_a, ["tags"]);
+                return (Object.assign(Object.assign({}, item), { template,
+                    region, name: (_b = item.name) !== null && _b !== void 0 ? _b : `Unnamed ${template.name} page`, tags: template.tags.flatMap(tagGroup => tagGroup.parse(tags)) }));
+            }) }, pagination);
+    }
+    async load(args) {
+        // try to load page (skip if there's no page at all)
+        const { eventBus, template } = args, query = __rest(args, ["eventBus", "template"]);
+        const data = await this.editorApi.getPageGroup(Object.assign(Object.assign({}, query), { type: template.type, version: 'draft' }));
+        if (!data) {
+            return undefined;
+        }
+        console.debug('[PageRepository/load] parsing page data', data);
+        // deserialize page (if any)
+        return PageSerializer_1.PageSerializer.deserializePageWithSummary(Object.assign(Object.assign({}, args), data));
+    }
+    async create(_a) {
+        var { eventBus, name } = _a, args = __rest(_a, ["eventBus", "name"]);
+        // resolve page (get or create)
+        const { template } = args, query = __rest(args, ["template"]);
+        const data = await this.editorApi.createPage(Object.assign(Object.assign({}, query), { type: template.type, name: name || template.name }));
+        // return page
+        return PageSerializer_1.PageSerializer.deserializePageWithSummary(Object.assign(Object.assign({ eventBus: eventBus !== null && eventBus !== void 0 ? eventBus : new funnel_core_1.EventBus() }, args), data));
+    }
+    async createLanguage(args) {
+        // resolve page (get or create)
+        const { eventBus, template } = args, query = __rest(args, ["eventBus", "template"]);
+        const data = await this.editorApi.createPage(Object.assign(Object.assign({}, query), { type: template.type }));
+        // return page
+        return PageSerializer_1.PageSerializer.deserializePageWithSummary(Object.assign(Object.assign({ region: data.group.region }, args), data));
+    }
+    async save(page) {
+        // get page update
+        const savables = [];
+        const update = this.serializePageUpdate(page, savables);
+        // start all updates
+        page.onSaveStart();
+        savables.forEach(savable => savable.onSaveStart());
+        // update page
+        const { updatedOn, changeSetId, page: pageData } = await this.editorApi.updatePage(update);
+        // complete all updates
+        savables.forEach(savable => savable.onSaveComplete());
+        page.onSaveComplete(updatedOn, changeSetId);
+        // return new page if it was updated
+        if (pageData) {
+            console.debug('[PageRepository/save] received new page');
+            const { eventBus, template, region } = page;
+            return PageSerializer_1.PageSerializer.deserializePage(Object.assign(Object.assign({}, pageData), { eventBus, template, region }));
+        }
+        // or simply update the page updated stamp
+        else {
+            console.debug('[PageRepository/save] received no page update but timestamp is now', updatedOn);
+            // return the same page
+            return page;
+        }
+    }
+    async unpublish(page) {
+        // throw if not valid
+        if (!page.published) {
+            throw new funnel_core_1.InvalidOperationError('Cannot unpublish page that is in draft state');
+        }
+        // unpublish page
+        await this.editorApi.unpublishPage(page.id);
+    }
+    serializePageUpdate(page, savables) {
+        var _a, _b;
+        // root page updates
+        const { id, discover, content } = page;
+        const rootPageUpdates = [];
+        // name
+        if (page.initialName !== page.name) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'name',
+                value: page.name
+            });
+        }
+        // tags
+        if (page.initialTags.symmetricDifference(page.tags).size > 0) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'tags',
+                value: Array.from(page.tags).map(tag => tag.data)
+            });
+        }
+        // slug + url
+        if (page.initialSlug !== page.slug) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'slug',
+                value: (_a = page.slug) !== null && _a !== void 0 ? _a : null
+            });
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'url',
+                value: page.url
+            });
+        }
+        // preview
+        const previewBlock = page.getPreviewBlock();
+        if (previewBlock && previewBlock.modified) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'preview',
+                value: previewBlock.value
+            });
+        }
+        // errors
+        if (page.initialErrors !== !page.valid) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'errors',
+                value: !page.valid
+            });
+        }
+        // publication
+        if (page.initialPublication !== page.publication) {
+            rootPageUpdates.push({
+                type: 'page',
+                property: 'publication',
+                value: (_b = page.publication) !== null && _b !== void 0 ? _b : null
+            });
+        }
+        // aggregate other updates
+        return {
+            id,
+            updatedOn: page.updatedOn,
+            updates: [
+                ...rootPageUpdates,
+                ...discover.reduce((updates, block) => {
+                    // try to update block
+                    this.serializeBlockUpdate(updates, block, 'discover', savables);
+                    // keep reducing
+                    return updates;
+                }, []),
+                ...content.reduce((updates, item) => {
+                    // handle block
+                    if (item instanceof domain_1.Block) {
+                        this.serializeBlockUpdate(updates, item, 'content', savables);
+                    }
+                    // or section
+                    else {
+                        this.serializeSectionUpdate(updates, item, 'content', savables);
+                    }
+                    // keep reducing
+                    return updates;
+                }, []),
+                ...page.deleteBlocks.map(block => ({
+                    type: 'block.delete',
+                    path: [block.area, block.key]
+                }))
+            ]
+        };
+    }
+    serializeSectionUpdate(updates, section, parentPath, savables) {
+        // track insert/update
+        let sectionChanged = false;
+        const path = [parentPath, section.key];
+        const { blocks, initialBlocks = [] } = section;
+        const blockIds = [];
+        blocks.forEach((sectionBlock, index) => {
+            // track id
+            const { id, block } = sectionBlock;
+            blockIds.push(id);
+            // track insert
+            const originalIndex = initialBlocks.findIndex(item => item.id === id);
+            if (originalIndex < 0) {
+                // add as insertion
+                updates.push({
+                    type: 'section.insert',
+                    path,
+                    index,
+                    section: {
+                        type: 'section',
+                        version: section.schema.version
+                    },
+                    block: sectionBlock.value
+                });
+                // mark changed
+                sectionChanged = true;
+                // track nested savables for section-block insertion
+                const fields = [...block.config, ...block.fields];
+                fields.forEach(field => {
+                    if (field.modified) {
+                        savables.push(field);
+                    }
+                });
+            }
+            // recurse update if it's set
+            else if (block.modified) {
+                // track name field
+                if (block.nameField.modified) {
+                    // send update
+                    updates.push({
+                        type: 'section.blockName',
+                        path,
+                        id,
+                        value: funnel_core_1.Schema.TextField.Value.fromData(block.nameField.value) || null
+                    });
+                    // track change
+                    savables.push(block.nameField);
+                }
+                // serialize config fields
+                this.serializeFieldsUpdate(updates, block.config, [...path, id, 'config'], savables);
+                // serialize content fields
+                this.serializeFieldsUpdate(updates, block.fields, [...path, id, 'fields'], savables);
+            }
+        });
+        // track delete/reorder
+        let reordered = false;
+        initialBlocks.forEach(({ id }, index) => {
+            // add to deleted list if the original doesn't exist anymore
+            const blockIndex = blockIds.findIndex(blockId => blockId === id);
+            if (blockIndex < 0) {
+                // delete
+                updates.push({
+                    type: 'section.delete',
+                    path,
+                    id
+                });
+                // track reorder
+                sectionChanged = true;
+            }
+            // or mark reorder if index isn't the same
+            else if (blockIndex !== index) {
+                reordered = true;
+                sectionChanged = true;
+            }
+        });
+        // track reorder
+        if (reordered) {
+            updates.push({
+                type: 'section.reorder',
+                path,
+                ids: blockIds
+            });
+        }
+        // track section change (if any)
+        if (sectionChanged) {
+            savables.push(section);
+        }
+    }
+    serializeBlockUpdate(updates, block, parentPath, savables) {
+        // ignore if block isn't activated
+        if (!block.activated) {
+            return;
+        }
+        // create a new block if it's new
+        else if (block.isNew) {
+            // create update
+            updates.push({
+                type: 'block.create',
+                path: [parentPath, block.key],
+                block: block.value
+            });
+            // track block
+            savables.push(block);
+            // track nested savables for block insertion
+            const fields = [...block.config, ...block.fields];
+            fields.forEach(field => {
+                if (field.modified) {
+                    savables.push(field);
+                }
+            });
+        }
+        // or just track updated fields
+        else {
+            // serialize config fields
+            this.serializeFieldsUpdate(updates, block.config, [parentPath, block.key, 'config'], savables);
+            // serialize content fields
+            this.serializeFieldsUpdate(updates, block.fields, [parentPath, block.key, 'fields'], savables);
+        }
+    }
+    serializeFieldsUpdate(updates, fields, parentPath, savables) {
+        // handle fields in block
+        fields.forEach(field => {
+            if (field instanceof funnel_core_1.Field) {
+                this.serializeFieldUpdate(updates, field, parentPath, savables);
+            }
+            else if (field instanceof funnel_core_1.ObjectField) {
+                this.serializeObjectFieldUpdate(updates, field, parentPath, savables);
+            }
+            else {
+                this.serializeListUpdate(updates, field, parentPath, savables);
+            }
+        });
+        // return changes (for chaining)
+        return updates;
+    }
+    serializeObjectFieldUpdate(updates, field, parentPath, savables) {
+        var _a;
+        // create object if it's new
+        if (field.isNew) {
+            // add insert
+            updates.push({
+                type: 'object.insert',
+                path: [...parentPath, field.id],
+                value: (_a = field.value) !== null && _a !== void 0 ? _a : null
+            });
+            // track save
+            savables.push(field);
+        }
+        // or process subfields
+        else if (field.exists) {
+            // save fields
+            this.serializeFieldsUpdate(updates, field.fields, [...parentPath, field.id], savables);
+            // track save
+            savables.push(field);
+        }
+        // or process opted out field
+        else if (field.optedOut) {
+            // remove field
+            updates.push({
+                type: 'value',
+                path: [...parentPath, field.id],
+                value: null
+            });
+            // track save
+            savables.push(field);
+        }
+    }
+    serializeFieldUpdate(updates, field, parentPath, savables) {
+        var _a;
+        // track change if modified (ignore if field is sandboxed)
+        if (field.modified && !field.sandboxed) {
+            // set field
+            updates.push({
+                type: 'value',
+                path: [...parentPath, field.id],
+                value: ((_a = field.value) !== null && _a !== void 0 ? _a : null)
+            });
+            // track save
+            savables.push(field);
+        }
+    }
+    serializeListUpdate(updates, list, parentPath, savables) {
+        var _a, _b;
+        // create list if it's new
+        if (list.isNew) {
+            // add new list
+            updates.push({
+                type: 'value',
+                path: [...parentPath, list.id],
+                value: funnel_core_1.Schema.Field.Data.newValue('list')
+            });
+            // track save
+            savables.push(list);
+        }
+        // or drop list on opt-out
+        else if (list.optedOut) {
+            // drop list
+            updates.push({
+                type: 'value',
+                path: [...parentPath, list.id],
+                value: null
+            });
+            // track save
+            savables.push(list);
+        }
+        // or if it is modified (otherwise ignore)
+        else if (list.modified) {
+            // add new list if there's nothing and it's new
+            const path = [...parentPath, list.id];
+            const { value: currentValue, items: fields, initialValue } = list;
+            const currentItems = (_a = currentValue === null || currentValue === void 0 ? void 0 : currentValue.value) !== null && _a !== void 0 ? _a : [];
+            const initialItems = (_b = initialValue === null || initialValue === void 0 ? void 0 : initialValue.value) !== null && _b !== void 0 ? _b : [];
+            const fieldIds = [];
+            // track inserts/updates of elements
+            currentItems.forEach((item, index) => {
+                // track id
+                const { id, field } = fields[index];
+                fieldIds.push(item.id);
+                // track insert
+                const originalIndex = initialItems.findIndex(initialItem => initialItem.id === id);
+                if (originalIndex < 0) {
+                    updates.push({
+                        type: 'array.insert',
+                        path,
+                        index,
+                        id,
+                        value: item
+                    });
+                }
+                // track update
+                else if (field.modified) {
+                    // object field updates should be recursed and indexed
+                    if (field instanceof funnel_core_1.ObjectField) {
+                        this.serializeFieldsUpdate(updates, field.fields, [...path, id], savables);
+                    }
+                    // basic field updates can be done inline
+                    else {
+                        updates.push({
+                            type: 'value',
+                            path: [...path, id],
+                            value: item
+                        });
+                    }
+                }
+            });
+            // track delete/reorder
+            let reordered = false;
+            let deleted = 0;
+            initialItems.forEach(({ id }, index) => {
+                // add to deleted list if the original doesn't exist anymore
+                const fieldIndex = fieldIds.findIndex(fieldId => fieldId === id) + deleted;
+                if (fieldIndex < 0) {
+                    updates.push({
+                        type: 'array.delete',
+                        path,
+                        id
+                    });
+                    // track deletion
+                    ++deleted;
+                }
+                // or mark reorder if index isn't the same
+                else if (fieldIndex !== index) {
+                    reordered = true;
+                }
+            });
+            // track reorder
+            if (reordered) {
+                updates.push({
+                    type: 'array.reorder',
+                    path,
+                    ids: fieldIds
+                });
+            }
+            // track save
+            savables.push(list);
+        }
+    }
+}
+exports.PageRepository = PageRepository;

package/dist/core/repository/PageSerializer.d.ts

@@ -0,0 +1,13 @@
+import { EventBus, Schema } from '@nascentdigital/funnel-core';
+import { Page } from '../domain';
+import { PageTarget } from './PageTarget';
+export declare namespace PageSerializer {
+    type DeserializePageWithSummaryArgs = Schema.Page.Data.AsGroup & PageTarget & {
+        eventBus: EventBus;
+    };
+    function deserializePageWithSummary({ eventBus, group: groupData, page: pageData, ...args }: DeserializePageWithSummaryArgs): Page.WithSummary;
+    type DeserializePageArgs = Schema.Page.Data & PageTarget & {
+        eventBus: EventBus;
+    };
+    function deserializePage({ eventBus, template, tags, discover, content, files, pages, collections, snapshot, ...data }: DeserializePageArgs): Page;
+}

package/dist/core/repository/PageSerializer.js

@@ -0,0 +1,182 @@
+"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.PageSerializer = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const domain_1 = require("../domain");
+const FieldSerializer_1 = require("./FieldSerializer");
+const TagSerializer_1 = require("./TagSerializer");
+// namespace
+var PageSerializer;
+(function (PageSerializer) {
+    function deserializePageWithSummary(_a) {
+        var { eventBus, group: groupData, page: pageData } = _a, args = __rest(_a, ["eventBus", "group", "page"]);
+        // deserialize page (if any)
+        const { template, region } = args;
+        const page = pageData && deserializePage(Object.assign(Object.assign({}, pageData), { template, region, eventBus }));
+        // deserialize summary
+        const { brand, groupId, instances } = groupData;
+        const summary = new domain_1.PageSummary(Object.assign(Object.assign({}, args), { brand,
+            groupId, pages: instances }));
+        // return result
+        return { summary, page };
+    }
+    PageSerializer.deserializePageWithSummary = deserializePageWithSummary;
+    function deserializePage(_a) {
+        var { eventBus, template, tags, discover = {}, content = {}, files = [], pages = [], collections = [], snapshot } = _a, data = __rest(_a, ["eventBus", "template", "tags", "discover", "content", "files", "pages", "collections", "snapshot"]);
+        // determine latest snapshot (if any)
+        const { discover: discoverSnapshot = {}, preview: previewSnapshot = {}, content: contentSnapshot = {} } = snapshot !== null && snapshot !== void 0 ? snapshot : {};
+        // create new page using shared bus
+        const region = data.region;
+        const pageSchemas = funnel_core_1.Schema.Site.current().regions[region];
+        const page = new domain_1.Page(Object.assign(Object.assign({ eventBus,
+            template, tags: TagSerializer_1.TagSerializer.deserializeTags({
+                groups: template.tags,
+                tagsData: tags
+            }) }, data), { discover: [
+                deserializeBlock({ schema: funnel_core_1.Schema.Seo, eventBus, key: 'seo', content: discover['seo'], snapshot: discoverSnapshot['seo'] })
+            ], content: Object.entries(template.content).map(([key, schema]) => deserializeContent({
+                key,
+                schema: schema.unwrap(),
+                eventBus,
+                content: content[key],
+                snapshot: contentSnapshot[key]
+            })), files, pages: pages.map((_a) => {
+                var { type, tags } = _a, ref = __rest(_a, ["type", "tags"]);
+                return (Object.assign(Object.assign({}, ref), { template: pageSchemas[type], tags: template.tags.flatMap(tagGroup => tagGroup.parse(tags)) }));
+            }), collections,
+            snapshot }));
+        // repair any issues on the page
+        page.repair();
+        // return page
+        return page;
+    }
+    PageSerializer.deserializePage = deserializePage;
+    function deserializeContent({ key, schema, content, eventBus, snapshot }) {
+        // handle section
+        if (schema instanceof funnel_core_1.Schema.Section) {
+            // fail if content isn't a section (unless it's undefined)
+            if (content && content.type !== 'section') {
+                console.error('[PageSerializer/deserializeContent] invalid section content', content);
+                throw new funnel_core_1.IllegalStateError(`Section content expected, but found "${content.type}" instead`);
+            }
+            // or if snapshot is invalid
+            else if (snapshot && snapshot.type !== 'section') {
+                throw new funnel_core_1.IllegalStateError(`Section snapshot expected, but found "${snapshot.type}" instead`);
+            }
+            // deserialize
+            return deserializeSection({
+                key,
+                eventBus,
+                schema,
+                content,
+                snapshot
+            });
+        }
+        // or handle block
+        else {
+            // fail if content isn't a section (unless it's undefined)
+            if (content && content.type !== 'block') {
+                console.error('[PageSerializer/deserializeContent] invalid block content', content);
+                throw new funnel_core_1.IllegalStateError(`Block content expected, but found "${content.type}" instead`);
+            }
+            // or if snapshot is invalid
+            else if (snapshot && snapshot.type !== 'block') {
+                throw new funnel_core_1.IllegalStateError(`Block snapshot expected, but found "${snapshot.type}" instead`);
+            }
+            // deserialize
+            return deserializeBlock({
+                key,
+                eventBus,
+                schema,
+                content,
+                snapshot
+            });
+        }
+    }
+    function deserializeSection({ key, eventBus, schema, content, snapshot }) {
+        // TODO: handle version mismatch (between schema + content) and upgrading
+        if (content && content.version !== schema.version) {
+            throw new funnel_core_1.NotImplementedError();
+        }
+        // deserialize
+        return new domain_1.Section({
+            key,
+            eventBus,
+            schema,
+            availableBlocks: Object.entries(schema.blocks).map(([key, schema]) => deserializeBlock({
+                key,
+                eventBus,
+                schema,
+                content: undefined,
+                snapshot: undefined
+            })),
+            blocks: content === null || content === void 0 ? void 0 : content.blocks.map(content => deserializeSectionBlock({
+                id: content.section.id,
+                key: content.section.block,
+                eventBus,
+                schema: schema.blocks[content.section.block],
+                content,
+                snapshot: snapshot === null || snapshot === void 0 ? void 0 : snapshot.blocks.find(({ section }) => section.id === content.section.id)
+            })),
+            required: false,
+            exists: content !== undefined
+        });
+    }
+    function deserializeSectionBlock({ id, key, eventBus, schema, content, snapshot }) {
+        // create block and return it (upgrade is handled in block deserialization)
+        return new domain_1.SectionBlock({
+            id,
+            key,
+            eventBus,
+            block: deserializeBlock({ key, eventBus, schema, content, snapshot }),
+            required: false,
+            exists: true
+        });
+    }
+    function deserializeBlock({ key, eventBus, schema, content: blockContent, snapshot }) {
+        // throw if there's a type mismatch
+        const { type = schema.type, version = schema.version, config = {}, fields = {} } = blockContent !== null && blockContent !== void 0 ? blockContent : {};
+        const { config: snapshotConfig = {}, fields: snapshotFields = {} } = snapshot !== null && snapshot !== void 0 ? snapshot : {};
+        if (type !== schema.type) {
+            throw new funnel_core_1.IllegalStateError(`Schema type mismatch for ${schema.name} block - expected "${schema.type}", found "${type}"`);
+        }
+        // TODO: handle version mismatch (between schema + content) and upgrading
+        if (version !== schema.version) {
+            throw new funnel_core_1.NotImplementedError(`Unable to upgrade ${schema.name} content from v${version} -> v${schema.version}`);
+        }
+        // create block and return it
+        return new domain_1.Block({
+            eventBus,
+            key,
+            schema,
+            fields: Object.entries(schema.editableFields).map(([id, schema]) => FieldSerializer_1.FieldSerializer.deserializeField({
+                id,
+                eventBus,
+                schema,
+                content: fields[id],
+                snapshot: snapshotFields[id]
+            })),
+            config: Object.entries(schema.config).map(([id, schema]) => FieldSerializer_1.FieldSerializer.deserializeField({
+                id,
+                eventBus,
+                schema: schema,
+                content: config[id],
+                snapshot: snapshotConfig[id]
+            })),
+            required: schema.required,
+            exists: blockContent !== undefined,
+            name: config.name
+        });
+    }
+})(PageSerializer || (exports.PageSerializer = PageSerializer = {}));

package/dist/core/repository/PageTarget.d.ts

@@ -0,0 +1,9 @@
+import { PageClient } from '@nascentdigital/funnel-cms';
+import { EventBus } from '@nascentdigital/funnel-core';
+import { Page } from '../domain';
+export type PageTarget = Pick<PageClient.Query.ByDetails, 'region' | 'language'> & Pick<Page.ConstructorArgs, 'template'>;
+export declare namespace PageTarget {
+    type WithEventBus = PageTarget & {
+        eventBus: EventBus;
+    };
+}

package/dist/core/repository/PageTarget.js

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

package/dist/core/repository/SiteRepository.d.ts

@@ -0,0 +1,5 @@
+import { EditorApiClient } from '../client';
+export declare class SiteRepository {
+    readonly editorApi: EditorApiClient;
+    constructor(editorApi: EditorApiClient);
+}