@ajf/material 13.0.0-next.0

package/esm2015/form-builder/form-builder-service.js

@@ -0,0 +1,764 @@
+/**
+ * @license
+ * Copyright (C) Gnucoop soc. coop.
+ *
+ * This file is part of the Advanced JSON forms (ajf).
+ *
+ * Advanced JSON forms (ajf) is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * Advanced JSON forms (ajf) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Advanced JSON forms (ajf).
+ * If not, see http://www.gnu.org/licenses/.
+ *
+ */
+import { AjfFieldType, AjfNodeType, createChoicesFixedOrigin, createContainerNode, createField, createForm, createValidation, createValidationGroup, createWarning, createWarningGroup, isChoicesFixedOrigin, isContainerNode, isField, isFieldWithChoices, isRepeatingContainerNode, isSlidesNode, maxDigitsValidation, maxValidation, minDigitsValidation, minValidation, notEmptyValidation, notEmptyWarning } from '@ajf/core/forms';
+import { alwaysCondition, createCondition, createFormula } from '@ajf/core/models';
+import { deepCopy } from '@ajf/core/utils';
+import { moveItemInArray } from '@angular/cdk/drag-drop';
+import { EventEmitter, Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, Subject, Subscription } from 'rxjs';
+import { filter, map, publishReplay, refCount, scan, withLatestFrom } from 'rxjs/operators';
+function getNodeContainer(c, node) {
+    if (c.nodes.indexOf(node) > -1) {
+        return c;
+    }
+    const cns = c.nodes.filter(n => isContainerNode(n));
+    const len = cns.length;
+    for (let i = 0; i < len; i++) {
+        const cn = getNodeContainer(cns[i], node);
+        if (cn != null) {
+            return cn;
+        }
+    }
+    return null;
+}
+function buildFormBuilderNodesSubtree(nodes, parent, ignoreConditionalBranches = false) {
+    const entries = nodes.filter(n => n.parent === parent.id)
+        .sort((n1, n2) => n1.parentNode - n2.parentNode)
+        .map(n => {
+        const children = buildFormBuilderNodesSubtree(nodes, n);
+        if (children.length === 0) {
+            children.push({ parent: n, parentNode: 0 });
+        }
+        return {
+            node: n,
+            children,
+            content: buildFormBuilderNodesContent(nodes, n)
+        };
+    });
+    if (!ignoreConditionalBranches) {
+        const entriesNum = entries.length;
+        const cbs = parent.conditionalBranches.length;
+        for (let i = entriesNum; i < cbs; i++) {
+            entries.push({ parent: parent, parentNode: i });
+        }
+    }
+    return entries;
+}
+function buildFormBuilderNodesContent(_nodes, node) {
+    if (isContainerNode(node)) {
+        return buildFormBuilderNodesSubtree(node.nodes, node, true);
+    }
+    return [];
+}
+export function flattenNodes(nodes) {
+    let flatNodes = [];
+    nodes.forEach((node) => {
+        if (isContainerNode(node)) {
+            flatNodes = flatNodes.concat(flattenNodes(node.nodes));
+        }
+        flatNodes.push(node);
+    });
+    return flatNodes;
+}
+function getDescendants(flatNodes, parentNode, branch = null) {
+    return branch != null ?
+        flatNodes.filter(n => n.parent === parentNode.id && n.parentNode === branch) :
+        flatNodes.filter(n => n.parent === parentNode.id);
+}
+function removeNodes(nodes, ids) {
+    const len = nodes.length;
+    for (let i = 0; i < len; i++) {
+        const node = nodes[i];
+        if (isContainerNode(node)) {
+            const container = node;
+            container.nodes = removeNodes(container.nodes, ids);
+        }
+    }
+    return nodes.filter(n => ids.indexOf(n.id) === -1);
+}
+function deleteNodeSubtree(nodes, parentNode, branch = null) {
+    const flatNodes = flattenNodes(nodes);
+    let delNodes = [];
+    let descendants = getDescendants(flatNodes, parentNode, branch);
+    const len = descendants.length;
+    for (let i = 0; i < len; i++) {
+        delNodes = delNodes.concat(getDescendants(flatNodes, descendants[i]));
+    }
+    delNodes = delNodes.concat(descendants);
+    return removeNodes(nodes, delNodes.map(n => n.id));
+}
+let nodeUniqueId = 0;
+export class AjfFormBuilderService {
+    constructor() {
+        this._availableNodeTypes = [
+            {
+                label: 'Slide',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-slide' },
+                nodeType: { node: AjfNodeType.AjfSlide },
+                isSlide: true
+            },
+            {
+                label: 'Repeating slide',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-repeatingslide' },
+                nodeType: { node: AjfNodeType.AjfRepeatingSlide },
+                isSlide: true
+            },
+            {
+                label: 'String',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-string' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.String }
+            },
+            {
+                label: 'Text',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-text' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Text }
+            },
+            {
+                label: 'Number',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-number' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Number }
+            },
+            {
+                label: 'Boolean',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-boolean' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Boolean }
+            },
+            {
+                label: 'Single choice',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-singlechoice' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.SingleChoice }
+            },
+            {
+                label: 'Multiple choice',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-multiplechoice' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.MultipleChoice }
+            },
+            {
+                label: 'Formula',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-formula' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Formula }
+            },
+            {
+                label: 'Date',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-date' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Date }
+            },
+            {
+                label: 'Date input',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-dateinput' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.DateInput }
+            },
+            {
+                label: 'Time',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-time' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Time }
+            },
+            {
+                label: 'Table',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-table' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Table }
+            },
+            {
+                label: 'Range',
+                icon: { fontSet: 'ajf-icon', fontIcon: 'field-range' },
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Range }
+            }
+        ];
+        this._form = new BehaviorSubject(null);
+        this._formObs = this._form;
+        /**
+         * A list of the ids of the dropLists connected to the source list.
+         */
+        this._connectedDropLists = new BehaviorSubject([]);
+        this._editedNodeEntry = new BehaviorSubject(null);
+        this._editedNodeEntryObs = this._editedNodeEntry;
+        this._editedCondition = new BehaviorSubject(null);
+        this._editedConditionObs = this._editedCondition;
+        this._editedChoicesOrigin = new BehaviorSubject(null);
+        this._editedChoicesOriginObs = this._editedChoicesOrigin;
+        this._beforeNodesUpdate = new EventEmitter();
+        this._beforeNodesUpdateObs = this._beforeNodesUpdate;
+        this._afterNodeUpdate = new EventEmitter();
+        this._afterNodeUpdateObs = this._afterNodeUpdate;
+        this._nodesUpdates = new Subject();
+        this._attachmentsOriginsUpdates = new Subject();
+        this._choicesOriginsUpdates = new Subject();
+        this._stringIdentifierUpdates = new Subject();
+        this._saveNodeEntryEvent = new EventEmitter();
+        this._deleteNodeEntryEvent = new EventEmitter();
+        /**
+         * Event fired when the position of a node in a tree changes.
+         */
+        this._moveNodeEntryEvent = new EventEmitter();
+        /**
+         * Subscribes to the moveNodeEntryEvent event emitter;
+         */
+        this._moveNodeSub = Subscription.EMPTY;
+        this._initChoicesOriginsStreams();
+        this._initAttachmentsOriginsStreams();
+        this._initStringIdentifierStreams();
+        this._initNodesStreams();
+        this._initFormStreams();
+        this._initSaveNode();
+        this._initMoveNode();
+        this._initDeleteNode();
+    }
+    /**
+     * Available node types
+     *
+     * @readonly
+     * @memberOf AjfFormBuilderService
+     */
+    get availableNodeTypes() {
+        return this._availableNodeTypes;
+    }
+    /**
+     * Current edited form stream
+     *
+     * @readonly
+     * @memberOf AjfFormBuilderService
+     */
+    get form() {
+        return this._formObs;
+    }
+    get attachmentsOrigins() {
+        return this._attachmentsOrigins;
+    }
+    get choicesOrigins() {
+        return this._choicesOrigins;
+    }
+    get stringIdentifier() {
+        return this._stringIdentifier;
+    }
+    get nodes() {
+        return this._nodes;
+    }
+    get flatNodes() {
+        return this._flatNodes;
+    }
+    get flatFields() {
+        return this._flatFields;
+    }
+    get nodeEntriesTree() {
+        return this._nodeEntriesTree;
+    }
+    get connectedDropLists() {
+        return this._connectedDropLists;
+    }
+    get editedNodeEntry() {
+        return this._editedNodeEntryObs;
+    }
+    get editedCondition() {
+        return this._editedConditionObs;
+    }
+    get editedChoicesOrigin() {
+        return this._editedChoicesOriginObs;
+    }
+    get beforeNodesUpdate() {
+        return this._beforeNodesUpdateObs;
+    }
+    get afterNodeUpdate() {
+        return this._afterNodeUpdateObs;
+    }
+    /**
+     * Sets the current edited form
+     *
+     * @param form
+     *
+     * @memberOf AjfFormBuilderService
+     */
+    setForm(form) {
+        if (form !== this._form.getValue()) {
+            this._form.next(form);
+        }
+    }
+    editNodeEntry(nodeEntry) {
+        this._editedNodeEntry.next(nodeEntry);
+    }
+    editCondition(condition) {
+        this._editedCondition.next(condition);
+    }
+    saveCurrentCondition(condition) {
+        let c = this._editedCondition.getValue();
+        if (c == null) {
+            return;
+        }
+        c.condition = condition;
+        this._editedCondition.next(null);
+    }
+    cancelConditionEdit() {
+        this._editedChoicesOrigin.next(null);
+    }
+    assignListId(node, empty = false) {
+        if (node.nodeType === AjfNodeType.AjfSlide || node.nodeType === AjfNodeType.AjfRepeatingSlide) {
+            const listId = empty ? `empty_fields_list_${node.id}` : `fields_list_${node.id}`;
+            if (this._connectedDropLists.value.indexOf(listId) == -1) {
+                this._connectDropList(listId);
+            }
+            return listId;
+        }
+        return '';
+    }
+    insertNode(nodeType, parent, parentNode, inContent = false, insertInIndex = 0) {
+        var _a;
+        let node;
+        const id = ++nodeUniqueId;
+        const isFieldNode = ((_a = nodeType.nodeType) === null || _a === void 0 ? void 0 : _a.field) != null;
+        if (isFieldNode) {
+            node = createField({
+                id,
+                nodeType: AjfNodeType.AjfField,
+                fieldType: nodeType.nodeType.field,
+                parent: parent.id,
+                parentNode,
+                name: '',
+            });
+        }
+        else {
+            node = createContainerNode({
+                id,
+                nodeType: nodeType.nodeType.node,
+                parent: 0,
+                parentNode,
+                name: '',
+                nodes: [],
+            });
+        }
+        this._beforeNodesUpdate.emit();
+        this._nodesUpdates.next((nodes) => {
+            const cn = isContainerNode(parent) && inContent ?
+                parent :
+                getNodeContainer({ nodes }, parent);
+            if (!isFieldNode) {
+                let newNodes = nodes.slice(0);
+                newNodes.splice(insertInIndex, 0, node);
+                newNodes = this._updateNodesList(0, newNodes);
+                return newNodes;
+            }
+            else {
+                let newNodes = cn.nodes.slice(0);
+                newNodes.splice(insertInIndex, 0, node);
+                newNodes = this._updateNodesList(cn.id, newNodes);
+                cn.nodes = newNodes;
+            }
+            return nodes;
+        });
+    }
+    saveNodeEntry(properties) {
+        this._saveNodeEntryEvent.emit(properties);
+    }
+    cancelNodeEntryEdit() {
+        this._editedNodeEntry.next(null);
+    }
+    deleteNodeEntry(nodeEntry) {
+        this._deleteNodeEntryEvent.next(nodeEntry);
+    }
+    /**
+     * Triggers the moveNode event when a node is moved in the formbuilder.
+     * @param nodeEntry The node to be moved.
+     */
+    moveNodeEntry(nodeEntry, from, to) {
+        const moveEvent = { nodeEntry: nodeEntry, fromIndex: from, toIndex: to };
+        this._moveNodeEntryEvent.next(moveEvent);
+    }
+    getCurrentForm() {
+        return combineLatest([
+            this.form, this._nodesWithoutChoiceOrigins, this.attachmentsOrigins,
+            this.choicesOrigins, this.stringIdentifier
+        ])
+            .pipe(filter(([form]) => form != null), map(([form, nodes, attachmentsOrigins, choicesOrigins, stringIdentifier]) => {
+            return createForm({
+                choicesOrigins: choicesOrigins.slice(0),
+                attachmentsOrigins: attachmentsOrigins.slice(0),
+                stringIdentifier: (stringIdentifier || []).slice(0),
+                nodes: nodes.slice(0),
+                supplementaryInformations: form.supplementaryInformations,
+            });
+        }));
+    }
+    editChoicesOrigin(choicesOrigin) {
+        this._editedChoicesOrigin.next(choicesOrigin);
+    }
+    createChoicesOrigin() {
+        this._editedChoicesOrigin.next(createChoicesFixedOrigin({ name: '' }));
+    }
+    cancelChoicesOriginEdit() {
+        this._editedChoicesOrigin.next(null);
+    }
+    saveChoicesOrigin(params) {
+        const choicesOrigin = this._editedChoicesOrigin.getValue();
+        if (choicesOrigin != null) {
+            choicesOrigin.label = params.label;
+            choicesOrigin.name = params.name;
+            if (isChoicesFixedOrigin(choicesOrigin)) {
+                choicesOrigin.choices = params.choices;
+            }
+            this._choicesOriginsUpdates.next((choicesOrigins) => {
+                const idx = choicesOrigins.indexOf(choicesOrigin);
+                if (idx > -1) {
+                    choicesOrigins = [
+                        ...choicesOrigins.slice(0, idx),
+                        choicesOrigin,
+                        ...choicesOrigins.slice(idx + 1),
+                    ];
+                }
+                else {
+                    choicesOrigins = [...choicesOrigins, choicesOrigin];
+                }
+                return choicesOrigins;
+            });
+        }
+        this._editedChoicesOrigin.next(null);
+    }
+    saveStringIdentifier(identifier) {
+        this._stringIdentifierUpdates.next(() => [...identifier]);
+    }
+    _buildFormBuilderNodesTree(nodes) {
+        this._updateNodesList(0, nodes);
+        const rootNodes = nodes.filter(n => n.nodeType == AjfNodeType.AjfSlide || n.nodeType == AjfNodeType.AjfRepeatingSlide);
+        if (rootNodes.length === 0) {
+            return [null];
+        }
+        const rootNode = rootNodes[0];
+        if (isSlidesNode(rootNode)) {
+            const tree = [];
+            tree.push({
+                node: rootNode,
+                container: null,
+                children: buildFormBuilderNodesSubtree(nodes, rootNode),
+                content: buildFormBuilderNodesContent(nodes, rootNode)
+            });
+            return tree;
+        }
+        throw new Error('Invalid form definition');
+    }
+    /**
+     * Adds the id of a dropList to be connected with the FormBuilder source list.
+     * @param listId The id of the list to connect.
+     */
+    _connectDropList(listId) {
+        let connectedLists = this._connectedDropLists.value.slice(0);
+        this._connectedDropLists.next([...connectedLists, listId]);
+    }
+    _findMaxNodeId(nodes, _curMaxId = 0) {
+        let maxId = 0;
+        nodes.forEach((n) => {
+            maxId = Math.max(maxId, n.id);
+            if (isContainerNode(n)) {
+                maxId = Math.max(maxId, this._findMaxNodeId(n.nodes));
+            }
+        });
+        return maxId;
+    }
+    _initFormStreams() {
+        this._form.subscribe((form) => {
+            nodeUniqueId = 0;
+            if (form != null && form.nodes != null && form.nodes.length > 0) {
+                nodeUniqueId = this._findMaxNodeId(form.nodes);
+            }
+            this._nodesUpdates.next((_nodes) => {
+                return form != null && form.nodes != null ? form.nodes.slice(0) : [];
+            });
+            this._attachmentsOriginsUpdates.next((_attachmentsOrigins) => {
+                return form != null && form.attachmentsOrigins != null ?
+                    form.attachmentsOrigins.slice(0) :
+                    [];
+            });
+            this._choicesOriginsUpdates.next((_choicesOrigins) => {
+                return form != null && form.choicesOrigins != null ? form.choicesOrigins.slice(0) : [];
+            });
+            this._stringIdentifierUpdates.next((_) => {
+                return form != null && form.stringIdentifier != null ? form.stringIdentifier.slice(0) :
+                    [];
+            });
+        });
+    }
+    _initChoicesOriginsStreams() {
+        this._choicesOrigins =
+            this._choicesOriginsUpdates
+                .pipe(scan((choicesOrigins, op) => {
+                return op(choicesOrigins);
+            }, []), publishReplay(1), refCount());
+    }
+    _initAttachmentsOriginsStreams() {
+        this._attachmentsOrigins = this._attachmentsOriginsUpdates.pipe(scan((attachmentsOrigins, op) => {
+            return op(attachmentsOrigins);
+        }, []), publishReplay(1), refCount());
+    }
+    _initStringIdentifierStreams() {
+        this._stringIdentifier = this._stringIdentifierUpdates.pipe(scan((stringIdentifier, op) => {
+            return op(stringIdentifier);
+        }, []), publishReplay(1), refCount());
+    }
+    _initNodesStreams() {
+        this._nodes = this._nodesUpdates
+            .pipe(scan((nodes, op) => {
+            return op(nodes);
+        }, []), publishReplay(1), refCount());
+        this._nodesWithoutChoiceOrigins =
+            this._nodes.pipe(map(slides => slides.map(slide => {
+                slide.nodes = slide.nodes.map((node) => {
+                    if (isFieldWithChoices(node)) {
+                        const fwc = deepCopy(node);
+                        if (fwc && fwc.choices) {
+                            delete fwc.choices;
+                        }
+                        if (fwc && fwc.choicesOrigin) {
+                            delete fwc.choicesOrigin;
+                        }
+                        return fwc;
+                    }
+                    return node;
+                });
+                return slide;
+            })));
+        this._flatNodes = this._nodes.pipe(map((nodes) => flattenNodes(nodes)), publishReplay(1), refCount());
+        this._flatFields = this._flatNodes.pipe(map((nodes) => nodes.filter(n => !isContainerNode(n))), publishReplay(1), refCount());
+        this._nodeEntriesTree = this._nodes.pipe(map(nodes => this._buildFormBuilderNodesTree(nodes)), publishReplay(1), refCount());
+    }
+    _initSaveNode() {
+        this._saveNodeEntryEvent
+            .pipe(withLatestFrom(this.editedNodeEntry, this.choicesOrigins, this.attachmentsOrigins), filter(([_, nodeEntry]) => nodeEntry != null), map(([properties, ne]) => {
+            this._beforeNodesUpdate.emit();
+            const nodeEntry = ne;
+            const origNode = nodeEntry.node;
+            const node = deepCopy(origNode);
+            node.id = nodeEntry.node.id;
+            node.name = properties.name;
+            node.label = properties.label;
+            node.visibility = properties.visibility != null ?
+                createCondition({ condition: properties.visibility }) :
+                null;
+            const oldConditionalBranches = node.conditionalBranches.length;
+            node.conditionalBranches = properties.conditionalBranches != null ?
+                properties.conditionalBranches.map((condition) => createCondition({ condition })) :
+                [alwaysCondition()];
+            const newConditionalBranches = node.conditionalBranches.length;
+            if (isRepeatingContainerNode(node)) {
+                const repNode = node;
+                repNode.formulaReps = properties.formulaReps != null ?
+                    createFormula({ formula: properties.formulaReps }) :
+                    undefined;
+                repNode.minReps = properties.minReps;
+                repNode.maxReps = properties.maxReps;
+            }
+            if (isField(node)) {
+                const field = node;
+                field.description = properties.description;
+                field.defaultValue = properties.defaultValue;
+                field.formula = properties.formula != null ?
+                    createFormula({ formula: properties.formula }) :
+                    undefined;
+                const forceValue = properties.value;
+                const notEmpty = properties.notEmpty;
+                const validationConditions = properties.validationConditions;
+                let minValue = parseInt(properties.minValue, 10);
+                let maxValue = parseInt(properties.maxValue, 10);
+                let minDigits = parseInt(properties.minDigits, 10);
+                let maxDigits = parseInt(properties.maxDigits, 10);
+                if (isNaN(minValue)) {
+                    minValue = null;
+                }
+                if (isNaN(maxValue)) {
+                    maxValue = null;
+                }
+                if (isNaN(minDigits)) {
+                    minDigits = null;
+                }
+                if (isNaN(maxDigits)) {
+                    maxDigits = null;
+                }
+                if (forceValue != null || notEmpty != null ||
+                    (validationConditions != null && validationConditions.length > 0) ||
+                    minValue != null || maxValue != null || minDigits != null ||
+                    maxDigits != null) {
+                    const validation = field.validation || createValidationGroup({});
+                    validation.forceValue = forceValue;
+                    validation.notEmpty = notEmpty ? notEmptyValidation() : undefined;
+                    validation.minValue = minValue != null ? minValidation(minValue) : undefined;
+                    validation.maxValue = maxValue != null ? maxValidation(maxValue) : undefined;
+                    validation.minDigits =
+                        minDigits != null ? minDigitsValidation(minDigits) : undefined;
+                    validation.maxDigits =
+                        maxDigits != null ? maxDigitsValidation(maxDigits) : undefined;
+                    validation.conditions =
+                        (validationConditions ||
+                            []).map((c) => createValidation({
+                            condition: c.condition,
+                            errorMessage: c.errorMessage
+                        }));
+                    field.validation = validation;
+                }
+                else {
+                    field.validation = undefined;
+                }
+                const notEmptyWarn = properties.notEmptyWarning;
+                const warningConditions = properties.warningConditions;
+                if (notEmptyWarn != null ||
+                    (warningConditions != null && warningConditions.length > 0)) {
+                    const warning = field.warning || createWarningGroup({});
+                    warning.notEmpty = notEmptyWarn ? notEmptyWarning() : undefined;
+                    warning.conditions =
+                        (warningConditions ||
+                            []).map((w) => createWarning({
+                            condition: w.condition,
+                            warningMessage: w.warningMessage
+                        }));
+                    field.warning = warning;
+                }
+                else {
+                    field.warning = undefined;
+                }
+                field.nextSlideCondition = properties.nextSlideCondition != null ?
+                    createCondition({ condition: properties.nextSlideCondition }) :
+                    undefined;
+                field.size = properties.size;
+                field.defaultValue = properties.defaultValue;
+                if (isFieldWithChoices(field)) {
+                    const fwc = field;
+                    fwc.choicesOriginRef = properties.choicesOriginRef;
+                    fwc.forceExpanded = properties.forceExpanded;
+                    fwc.forceNarrow = properties.forceNarrow;
+                    fwc.triggerConditions = (properties.triggerConditions ||
+                        []).map((t) => createCondition({ condition: t }));
+                }
+            }
+            this._editedNodeEntry.next(null);
+            return (nodes) => {
+                let cn = getNodeContainer({ nodes }, origNode);
+                if (cn != null) {
+                    // TODO: @trik check this, was always true?
+                    // if (cn instanceof AjfNode) {
+                    const replaceNodes = cn.nodes === nodes;
+                    const idx = cn.nodes.indexOf(origNode);
+                    let newNodes = cn.nodes.slice(0, idx);
+                    newNodes.push(node);
+                    newNodes = newNodes.concat(cn.nodes.slice(idx + 1));
+                    cn.nodes = newNodes;
+                    if (replaceNodes) {
+                        nodes = newNodes;
+                    }
+                    else {
+                        nodes = nodes.slice(0);
+                    }
+                    // } else {
+                    //   const idx = nodes.indexOf(origNode);
+                    //   nodes = nodes.slice(0, idx).concat([node]).concat(nodes.slice(idx + 1));
+                    // }
+                    if (newConditionalBranches < oldConditionalBranches) {
+                        for (let i = newConditionalBranches; i < oldConditionalBranches; i++) {
+                            nodes = deleteNodeSubtree(nodes, node, i);
+                        }
+                    }
+                }
+                return nodes;
+            };
+        }))
+            .subscribe(this._nodesUpdates);
+    }
+    _initDeleteNode() {
+        this._deleteNodeEntryEvent
+            .pipe(map((nodeEntry) => {
+            this._beforeNodesUpdate.emit();
+            return (nodes) => {
+                const node = nodeEntry.node;
+                let cn = getNodeContainer({ nodes }, node);
+                if (cn != null) {
+                    const replaceNodes = cn.nodes === nodes;
+                    const idx = cn.nodes.indexOf(node);
+                    let newNodes = cn.nodes.slice(0, idx);
+                    newNodes = newNodes.concat(cn.nodes.slice(idx + 1));
+                    cn.nodes = newNodes;
+                    if (replaceNodes) {
+                        nodes = newNodes;
+                    }
+                    else {
+                        nodes = nodes.slice(0);
+                    }
+                }
+                return nodes;
+            };
+        }))
+            .subscribe(this._nodesUpdates);
+    }
+    /**
+     * Initializes the subscription to the moveNodeEntryEvent.
+     */
+    _initMoveNode() {
+        this._moveNodeSub.unsubscribe();
+        this._moveNodeSub =
+            this._moveNodeEntryEvent
+                .pipe(map((moveEvent) => {
+                this._beforeNodesUpdate.emit();
+                return (nodes) => {
+                    const nodeEntry = moveEvent.nodeEntry;
+                    const node = nodeEntry.node;
+                    let cn = getNodeContainer({ nodes }, node);
+                    let newNodes = nodes;
+                    if (cn != null) {
+                        const replaceNodes = cn.nodes === nodes;
+                        newNodes = cn.nodes;
+                        moveItemInArray(newNodes, moveEvent.fromIndex, moveEvent.toIndex);
+                        newNodes = this._updateNodesList(cn.id, newNodes);
+                        cn.nodes = newNodes;
+                        if (replaceNodes) {
+                            nodes = newNodes;
+                        }
+                        else {
+                            nodes = nodes.slice(0);
+                        }
+                    }
+                    return nodes;
+                };
+            }))
+                .subscribe(this._nodesUpdates);
+    }
+    /**
+     * Updates the "id" and "parent" fields of a modified or rearranged list of nodes.
+     * @param containerId The id of the parent container of the list.
+     * @param nodesList The list of nodes to be updated.
+     */
+    _updateNodesList(containerId, nodesList) {
+        if (!nodesList.length) {
+            return [];
+        }
+        const contId = containerId != undefined ? containerId : 0;
+        for (let idx = 0; idx < nodesList.length; idx++) {
+            let currentNode = nodesList[idx];
+            currentNode.id = (contId * 1000) + idx + 1;
+            currentNode.parent = idx == 0 ? contId : (contId * 1000) + idx;
+            if (currentNode.nodeType == AjfNodeType.AjfSlide ||
+                currentNode.nodeType == AjfNodeType.AjfRepeatingSlide) {
+                const currentSlide = currentNode;
+                if (currentSlide.nodes) {
+                    this._updateNodesList(currentSlide.id, currentSlide.nodes);
+                }
+            }
+        }
+        return nodesList;
+    }
+}
+AjfFormBuilderService.decorators = [
+    { type: Injectable }
+];
+AjfFormBuilderService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-builder-service.js","sourceRoot":"","sources":["../../../../../../src/material/form-builder/form-builder-service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright (C) Gnucoop soc. coop.\n *\n * This file is part of the Advanced JSON forms (ajf).\n *\n * Advanced JSON forms (ajf) is free software: you can redistribute it and/or\n * modify it under the terms of the GNU Affero General Public License as\n * published by the Free Software Foundation, either version 3 of the License,\n * or (at your option) any later version.\n *\n * Advanced JSON forms (ajf) is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero\n * General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Advanced JSON forms (ajf).\n * If not, see http://www.gnu.org/licenses/.\n *\n */\n\nimport {\n  AjfAttachmentsOrigin,\n  AjfChoicesOrigin,\n  AjfField,\n  AjfFieldType,\n  AjfFieldWithChoices,\n  AjfForm,\n  AjfFormStringIdentifier,\n  AjfNode,\n  AjfNodeGroup,\n  AjfNodesOperation,\n  AjfNodeType,\n  AjfRepeatingContainerNode,\n  AjfRepeatingSlide,\n  AjfSlide,\n  createChoicesFixedOrigin,\n  createContainerNode,\n  createField,\n  createForm,\n  createValidation,\n  createValidationGroup,\n  createWarning,\n  createWarningGroup,\n  isChoicesFixedOrigin,\n  isContainerNode,\n  isField,\n  isFieldWithChoices,\n  isRepeatingContainerNode,\n  isSlidesNode,\n  maxDigitsValidation,\n  maxValidation,\n  minDigitsValidation,\n  minValidation,\n  notEmptyValidation,\n  notEmptyWarning\n} from '@ajf/core/forms';\nimport {AjfCondition, alwaysCondition, createCondition, createFormula} from '@ajf/core/models';\nimport {deepCopy} from '@ajf/core/utils';\nimport {moveItemInArray} from '@angular/cdk/drag-drop';\nimport {EventEmitter, Injectable} from '@angular/core';\nimport {BehaviorSubject, combineLatest, Observable, Subject, Subscription} from 'rxjs';\nimport {filter, map, publishReplay, refCount, scan, withLatestFrom} from 'rxjs/operators';\n\nimport {\n  AjfAttachmentsOriginsOperation,\n  AjfChoicesOriginsOperation,\n  AjfFormStringIdentifierOperation\n} from './operations';\n\n\nexport interface AjfFormBuilderNodeTypeEntry {\n  label: string;\n  icon: {fontSet: string, fontIcon: string};\n  nodeType: {\n    node: AjfNodeType;\n    field?: AjfFieldType,\n  };\n  isSlide?: boolean;\n}\n\n\nexport interface AjfFormBuilderNodeEntry {\n  node: AjfNode;\n  container: AjfContainerNode|null;\n  children: AjfFormBuilderNodeEntry[];\n  content: AjfFormBuilderNodeEntry[];\n}\n\n\nexport interface AjfFormBuilderEmptySlot {\n  parent: AjfNode;\n  parentNode: number;\n}\n\n/**\n * Represents a node's position change in the formbuilder.\n */\nexport interface AjfFormBuilderMoveEvent {\n  /**\n   * The node being moved.\n   */\n  nodeEntry: AjfFormBuilderNode;\n\n  /**\n   * The index of the node previous position.\n   */\n  fromIndex: number;\n\n  /**\n   * The index of the node new position.\n   */\n  toIndex: number;\n}\n\n\nexport type AjfFormBuilderNode = AjfFormBuilderNodeEntry|AjfFormBuilderEmptySlot;\nexport type AjfContainerNode = AjfSlide|AjfRepeatingSlide|AjfNodeGroup;\n\nfunction getNodeContainer(c: {nodes: AjfNode[]}, node: AjfNode): {nodes: AjfNode[]}|null {\n  if (c.nodes.indexOf(node) > -1) {\n    return c;\n  }\n  const cns = c.nodes.filter(n => isContainerNode(n));\n  const len = cns.length;\n  for (let i = 0; i < len; i++) {\n    const cn = getNodeContainer(<AjfContainerNode>cns[i], node);\n    if (cn != null) {\n      return cn;\n    }\n  }\n  return null;\n}\n\nfunction buildFormBuilderNodesSubtree(\n    nodes: AjfNode[], parent: AjfNode, ignoreConditionalBranches = false): AjfFormBuilderNode[] {\n  const entries: AjfFormBuilderNode[] = nodes.filter(n => n.parent === parent.id)\n                                            .sort((n1, n2) => n1.parentNode - n2.parentNode)\n                                            .map(n => {\n                                              const children =\n                                                  buildFormBuilderNodesSubtree(nodes, n);\n                                              if (children.length === 0) {\n                                                children.push({parent: n, parentNode: 0});\n                                              }\n                                              return <AjfFormBuilderNodeEntry>{\n                                                node: n,\n                                                children,\n                                                content: buildFormBuilderNodesContent(nodes, n)\n                                              };\n                                            });\n  if (!ignoreConditionalBranches) {\n    const entriesNum = entries.length;\n    const cbs = parent.conditionalBranches.length;\n    for (let i = entriesNum; i < cbs; i++) {\n      entries.push({parent: parent, parentNode: i});\n    }\n  }\n  return entries;\n}\n\nfunction buildFormBuilderNodesContent(_nodes: AjfNode[], node: AjfNode): AjfFormBuilderNode[] {\n  if (isContainerNode(node)) {\n    return buildFormBuilderNodesSubtree((<AjfContainerNode>node).nodes, node, true);\n  }\n  return [];\n}\n\nexport function flattenNodes(nodes: AjfNode[]): AjfNode[] {\n  let flatNodes: AjfNode[] = [];\n\n  nodes.forEach((node: AjfNode) => {\n    if (isContainerNode(node)) {\n      flatNodes = flatNodes.concat(flattenNodes((<AjfContainerNode>node).nodes));\n    }\n    flatNodes.push(node);\n  });\n\n  return flatNodes;\n}\n\nfunction getDescendants(\n    flatNodes: AjfNode[], parentNode: AjfNode, branch: number|null = null): AjfNode[] {\n  return branch != null ?\n      flatNodes.filter(n => n.parent === parentNode.id && n.parentNode === branch) :\n      flatNodes.filter(n => n.parent === parentNode.id);\n}\n\nfunction removeNodes(nodes: AjfNode[], ids: number[]): AjfNode[] {\n  const len = nodes.length;\n  for (let i = 0; i < len; i++) {\n    const node = nodes[i];\n    if (isContainerNode(node)) {\n      const container = (<AjfContainerNode>node);\n      container.nodes = removeNodes(container.nodes, ids);\n    }\n  }\n  return nodes.filter(n => ids.indexOf(n.id) === -1);\n}\n\nfunction deleteNodeSubtree(\n    nodes: AjfNode[], parentNode: AjfNode, branch: number|null = null): AjfNode[] {\n  const flatNodes = flattenNodes(nodes);\n  let delNodes: AjfNode[] = [];\n  let descendants = getDescendants(flatNodes, parentNode, branch);\n  const len = descendants.length;\n  for (let i = 0; i < len; i++) {\n    delNodes = delNodes.concat(getDescendants(flatNodes, descendants[i]));\n  }\n  delNodes = delNodes.concat(descendants);\n  return removeNodes(nodes, delNodes.map(n => n.id));\n}\n\nlet nodeUniqueId = 0;\n\n\n@Injectable()\nexport class AjfFormBuilderService {\n  private _availableNodeTypes: AjfFormBuilderNodeTypeEntry[] = [\n    {\n      label: 'Slide',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-slide'},\n      nodeType: {node: AjfNodeType.AjfSlide},\n      isSlide: true\n    },\n    {\n      label: 'Repeating slide',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-repeatingslide'},\n      nodeType: {node: AjfNodeType.AjfRepeatingSlide},\n      isSlide: true\n    },\n    {\n      label: 'String',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-string'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.String}\n    },\n    {\n      label: 'Text',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-text'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Text}\n    },\n    {\n      label: 'Number',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-number'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Number}\n    },\n    {\n      label: 'Boolean',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-boolean'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Boolean}\n    },\n    {\n      label: 'Single choice',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-singlechoice'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.SingleChoice}\n    },\n    {\n      label: 'Multiple choice',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-multiplechoice'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.MultipleChoice}\n    },\n    {\n      label: 'Formula',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-formula'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Formula}\n    },\n    {\n      label: 'Date',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-date'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Date}\n    },\n    {\n      label: 'Date input',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-dateinput'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.DateInput}\n    },\n    {\n      label: 'Time',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-time'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Time}\n    },\n    {\n      label: 'Table',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-table'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Table}\n    },\n    {\n      label: 'Range',\n      icon: {fontSet: 'ajf-icon', fontIcon: 'field-range'},\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Range}\n    }\n  ];\n  /**\n   * Available node types\n   *\n   * @readonly\n   * @memberOf AjfFormBuilderService\n   */\n  get availableNodeTypes(): AjfFormBuilderNodeTypeEntry[] {\n    return this._availableNodeTypes;\n  }\n\n  private _form: BehaviorSubject<AjfForm|null> = new BehaviorSubject<AjfForm|null>(null);\n  private _formObs: Observable<AjfForm|null> = this._form as Observable<AjfForm|null>;\n\n  /**\n   * Current edited form stream\n   *\n   * @readonly\n   * @memberOf AjfFormBuilderService\n   */\n  get form(): Observable<AjfForm|null> {\n    return this._formObs;\n  }\n\n  private _attachmentsOrigins: Observable<AjfAttachmentsOrigin<any>[]>;\n  get attachmentsOrigins(): Observable<AjfAttachmentsOrigin<any>[]> {\n    return this._attachmentsOrigins;\n  }\n\n  private _choicesOrigins: Observable<AjfChoicesOrigin<any>[]>;\n  get choicesOrigins(): Observable<AjfChoicesOrigin<any>[]> {\n    return this._choicesOrigins;\n  }\n\n  private _stringIdentifier: Observable<AjfFormStringIdentifier[]>;\n  get stringIdentifier(): Observable<AjfFormStringIdentifier[]> {\n    return this._stringIdentifier;\n  }\n\n  private _nodesWithoutChoiceOrigins: Observable<AjfSlide[]>;\n  private _nodes: Observable<AjfNode[]>;\n  get nodes(): Observable<AjfNode[]> {\n    return this._nodes;\n  }\n\n  private _flatNodes: Observable<AjfNode[]>;\n  get flatNodes(): Observable<AjfNode[]> {\n    return this._flatNodes;\n  }\n\n  private _flatFields: Observable<AjfField[]>;\n  get flatFields(): Observable<AjfField[]> {\n    return this._flatFields;\n  }\n\n  private _nodeEntriesTree: Observable<AjfFormBuilderNodeEntry[]>;\n  get nodeEntriesTree(): Observable<AjfFormBuilderNodeEntry[]> {\n    return this._nodeEntriesTree;\n  }\n\n  /**\n   * A list of the ids of the dropLists connected to the source list.\n   */\n  private _connectedDropLists: BehaviorSubject<string[]> = new BehaviorSubject<string[]>([]);\n  get connectedDropLists(): BehaviorSubject<string[]> {\n    return this._connectedDropLists;\n  }\n\n  private _editedNodeEntry: BehaviorSubject<AjfFormBuilderNodeEntry|null> =\n      new BehaviorSubject<AjfFormBuilderNodeEntry|null>(null);\n  private _editedNodeEntryObs: Observable<AjfFormBuilderNodeEntry|null> =\n      this._editedNodeEntry as Observable<AjfFormBuilderNodeEntry|null>;\n  get editedNodeEntry(): Observable<AjfFormBuilderNodeEntry|null> {\n    return this._editedNodeEntryObs;\n  }\n\n  private _editedCondition: BehaviorSubject<AjfCondition|null> =\n      new BehaviorSubject<AjfCondition|null>(null);\n  private _editedConditionObs: Observable<AjfCondition|null> =\n      this._editedCondition as Observable<AjfCondition|null>;\n  get editedCondition(): Observable<AjfCondition|null> {\n    return this._editedConditionObs;\n  }\n\n  private _editedChoicesOrigin: BehaviorSubject<AjfChoicesOrigin<any>|null> =\n      new BehaviorSubject<AjfChoicesOrigin<any>|null>(null);\n  private _editedChoicesOriginObs: Observable<AjfChoicesOrigin<any>|null> =\n      this._editedChoicesOrigin as Observable<AjfChoicesOrigin<any>|null>;\n  get editedChoicesOrigin(): Observable<AjfChoicesOrigin<any>|null> {\n    return this._editedChoicesOriginObs;\n  }\n\n  private _beforeNodesUpdate: EventEmitter<void> = new EventEmitter<void>();\n  private _beforeNodesUpdateObs: Observable<void> = this._beforeNodesUpdate as Observable<void>;\n  get beforeNodesUpdate(): Observable<void> {\n    return this._beforeNodesUpdateObs;\n  }\n  private _afterNodeUpdate: EventEmitter<void> = new EventEmitter<void>();\n  private _afterNodeUpdateObs: Observable<void> = this._afterNodeUpdate as Observable<void>;\n  get afterNodeUpdate(): Observable<void> {\n    return this._afterNodeUpdateObs;\n  }\n\n  private _nodesUpdates: Subject<AjfNodesOperation> = new Subject<AjfNodesOperation>();\n  private _attachmentsOriginsUpdates: Subject<AjfAttachmentsOriginsOperation> =\n      new Subject<AjfAttachmentsOriginsOperation>();\n  private _choicesOriginsUpdates: Subject<AjfChoicesOriginsOperation> =\n      new Subject<AjfChoicesOriginsOperation>();\n  private _stringIdentifierUpdates: Subject<AjfFormStringIdentifierOperation> =\n      new Subject<AjfFormStringIdentifierOperation>();\n\n  private _saveNodeEntryEvent: EventEmitter<any> = new EventEmitter<any>();\n  private _deleteNodeEntryEvent: EventEmitter<AjfFormBuilderNodeEntry> =\n      new EventEmitter<AjfFormBuilderNodeEntry>();\n  /**\n   * Event fired when the position of a node in a tree changes.\n   */\n  private _moveNodeEntryEvent: EventEmitter<AjfFormBuilderMoveEvent> =\n      new EventEmitter<AjfFormBuilderMoveEvent>();\n\n  /**\n   * Subscribes to the moveNodeEntryEvent event emitter;\n   */\n  private _moveNodeSub: Subscription = Subscription.EMPTY;\n\n  constructor() {\n    this._initChoicesOriginsStreams();\n    this._initAttachmentsOriginsStreams();\n    this._initStringIdentifierStreams();\n    this._initNodesStreams();\n    this._initFormStreams();\n    this._initSaveNode();\n    this._initMoveNode();\n    this._initDeleteNode();\n  }\n\n  /**\n   * Sets the current edited form\n   *\n   * @param form\n   *\n   * @memberOf AjfFormBuilderService\n   */\n  setForm(form: AjfForm|null): void {\n    if (form !== this._form.getValue()) {\n      this._form.next(form);\n    }\n  }\n\n  editNodeEntry(nodeEntry: AjfFormBuilderNodeEntry): void {\n    this._editedNodeEntry.next(nodeEntry);\n  }\n\n  editCondition(condition: AjfCondition): void {\n    this._editedCondition.next(condition);\n  }\n\n  saveCurrentCondition(condition: string): void {\n    let c = this._editedCondition.getValue();\n    if (c == null) {\n      return;\n    }\n    c.condition = condition;\n    this._editedCondition.next(null);\n  }\n\n  cancelConditionEdit(): void {\n    this._editedChoicesOrigin.next(null);\n  }\n\n  assignListId(node: AjfNode, empty: boolean = false): string {\n    if (node.nodeType === AjfNodeType.AjfSlide || node.nodeType === AjfNodeType.AjfRepeatingSlide) {\n      const listId = empty ? `empty_fields_list_${node.id}` : `fields_list_${node.id}`;\n      if (this._connectedDropLists.value.indexOf(listId) == -1) {\n        this._connectDropList(listId);\n      }\n      return listId;\n    }\n    return '';\n  }\n\n  insertNode(\n      nodeType: AjfFormBuilderNodeTypeEntry, parent: AjfNode, parentNode: number, inContent = false,\n      insertInIndex = 0): void {\n    let node: AjfNode|AjfField;\n    const id = ++nodeUniqueId;\n    const isFieldNode = nodeType.nodeType?.field != null;\n    if (isFieldNode) {\n      node = createField({\n        id,\n        nodeType: AjfNodeType.AjfField,\n        fieldType: nodeType.nodeType.field!,\n        parent: parent.id,\n        parentNode,\n        name: '',\n      });\n    } else {\n      node = createContainerNode({\n        id,\n        nodeType: nodeType.nodeType.node,\n        parent: 0,\n        parentNode,\n        name: '',\n        nodes: [],\n      });\n    }\n    this._beforeNodesUpdate.emit();\n    this._nodesUpdates.next((nodes: AjfNode[]): AjfNode[] => {\n      const cn = isContainerNode(parent) && inContent ?\n          (<AjfContainerNode>parent) :\n          getNodeContainer({nodes}, parent) as AjfContainerNode;\n      if (!isFieldNode) {\n        let newNodes = nodes.slice(0);\n        newNodes.splice(insertInIndex, 0, node);\n        newNodes = this._updateNodesList(0, newNodes);\n        return newNodes;\n      } else {\n        let newNodes = cn.nodes.slice(0);\n        newNodes.splice(insertInIndex, 0, node);\n        newNodes = this._updateNodesList(cn.id, newNodes);\n        cn.nodes = newNodes;\n      }\n      return nodes;\n    });\n  }\n\n  saveNodeEntry(properties: any): void {\n    this._saveNodeEntryEvent.emit(properties);\n  }\n\n  cancelNodeEntryEdit(): void {\n    this._editedNodeEntry.next(null);\n  }\n\n  deleteNodeEntry(nodeEntry: AjfFormBuilderNodeEntry): void {\n    this._deleteNodeEntryEvent.next(nodeEntry);\n  }\n\n  /**\n   * Triggers the moveNode event when a node is moved in the formbuilder.\n   * @param nodeEntry The node to be moved.\n   */\n  moveNodeEntry(nodeEntry: AjfFormBuilderNodeEntry, from: number, to: number): void {\n    const moveEvent: AjfFormBuilderMoveEvent = {nodeEntry: nodeEntry, fromIndex: from, toIndex: to};\n    this._moveNodeEntryEvent.next(moveEvent);\n  }\n\n  getCurrentForm(): Observable<AjfForm> {\n    return combineLatest([\n             this.form, this._nodesWithoutChoiceOrigins, this.attachmentsOrigins,\n             this.choicesOrigins, this.stringIdentifier\n           ])\n        .pipe(\n            filter(([form]) => form != null),\n            map(([form, nodes, attachmentsOrigins, choicesOrigins, stringIdentifier]) => {\n              return createForm({\n                choicesOrigins: (choicesOrigins as AjfChoicesOrigin<any>[]).slice(0),\n                attachmentsOrigins: (attachmentsOrigins as AjfAttachmentsOrigin<any>[]).slice(0),\n                stringIdentifier: ((stringIdentifier || []) as AjfFormStringIdentifier[]).slice(0),\n                nodes: (nodes as AjfSlide[]).slice(0),\n                supplementaryInformations: (form as AjfForm).supplementaryInformations,\n              });\n            }));\n  }\n\n  editChoicesOrigin(choicesOrigin: AjfChoicesOrigin<any>): void {\n    this._editedChoicesOrigin.next(choicesOrigin);\n  }\n\n  createChoicesOrigin(): void {\n    this._editedChoicesOrigin.next(createChoicesFixedOrigin<any>({name: ''}));\n  }\n\n  cancelChoicesOriginEdit(): void {\n    this._editedChoicesOrigin.next(null);\n  }\n\n  saveChoicesOrigin(params: {label: string, name: string, choices: any[]}): void {\n    const choicesOrigin = this._editedChoicesOrigin.getValue();\n    if (choicesOrigin != null) {\n      choicesOrigin.label = params.label;\n      choicesOrigin.name = params.name;\n      if (isChoicesFixedOrigin(choicesOrigin)) {\n        choicesOrigin.choices = params.choices;\n      }\n      this._choicesOriginsUpdates.next((choicesOrigins) => {\n        const idx = choicesOrigins.indexOf(choicesOrigin);\n        if (idx > -1) {\n          choicesOrigins = [\n            ...choicesOrigins.slice(0, idx),\n            choicesOrigin,\n            ...choicesOrigins.slice(idx + 1),\n          ];\n        } else {\n          choicesOrigins = [...choicesOrigins, choicesOrigin];\n        }\n        return choicesOrigins;\n      });\n    }\n    this._editedChoicesOrigin.next(null);\n  }\n\n  saveStringIdentifier(identifier: AjfFormStringIdentifier[]): void {\n    this._stringIdentifierUpdates.next(() => [...identifier]);\n  }\n\n  private _buildFormBuilderNodesTree(nodes: AjfNode[]): (AjfFormBuilderNode|null)[] {\n    this._updateNodesList(0, nodes);\n    const rootNodes = nodes.filter(\n        n => n.nodeType == AjfNodeType.AjfSlide || n.nodeType == AjfNodeType.AjfRepeatingSlide);\n    if (rootNodes.length === 0) {\n      return [null];\n    }\n    const rootNode = rootNodes[0];\n    if (isSlidesNode(rootNode)) {\n      const tree: AjfFormBuilderNode[] = [];\n      tree.push(<AjfFormBuilderNodeEntry>{\n        node: rootNode,\n        container: null,\n        children: buildFormBuilderNodesSubtree(nodes, rootNode),\n        content: buildFormBuilderNodesContent(nodes, rootNode)\n      });\n      return tree;\n    }\n    throw new Error('Invalid form definition');\n  }\n\n  /**\n   * Adds the id of a dropList to be connected with the FormBuilder source list.\n   * @param listId The id of the list to connect.\n   */\n  private _connectDropList(listId: string) {\n    let connectedLists = this._connectedDropLists.value.slice(0);\n    this._connectedDropLists.next([...connectedLists, listId]);\n  }\n\n  private _findMaxNodeId(nodes: AjfNode[], _curMaxId = 0): number {\n    let maxId = 0;\n    nodes.forEach((n) => {\n      maxId = Math.max(maxId, n.id);\n      if (isContainerNode(n)) {\n        maxId = Math.max(maxId, this._findMaxNodeId((<AjfContainerNode>n).nodes));\n      }\n    });\n    return maxId;\n  }\n\n  private _initFormStreams(): void {\n    this._form.subscribe((form: AjfForm|null) => {\n      nodeUniqueId = 0;\n      if (form != null && form.nodes != null && form.nodes.length > 0) {\n        nodeUniqueId = this._findMaxNodeId(form.nodes);\n      }\n      this._nodesUpdates.next((_nodes: AjfNode[]): AjfNode[] => {\n        return form != null && form.nodes != null ? form.nodes.slice(0) : [];\n      });\n      this._attachmentsOriginsUpdates.next(\n          (_attachmentsOrigins: AjfAttachmentsOrigin<any>[]): AjfAttachmentsOrigin<any>[] => {\n            return form != null && form.attachmentsOrigins != null ?\n                form.attachmentsOrigins.slice(0) :\n                [];\n          });\n      this._choicesOriginsUpdates.next(\n          (_choicesOrigins: AjfChoicesOrigin<any>[]): AjfChoicesOrigin<any>[] => {\n            return form != null && form.choicesOrigins != null ? form.choicesOrigins.slice(0) : [];\n          });\n      this._stringIdentifierUpdates.next(\n          (_: AjfFormStringIdentifier[]): AjfFormStringIdentifier[] => {\n            return form != null && form.stringIdentifier != null ? form.stringIdentifier.slice(0) :\n                                                                   [];\n          });\n    });\n  }\n\n  private _initChoicesOriginsStreams(): void {\n    this._choicesOrigins =\n        (<Observable<AjfChoicesOriginsOperation>>this._choicesOriginsUpdates)\n            .pipe(\n                scan((choicesOrigins: AjfChoicesOrigin<any>[], op: AjfChoicesOriginsOperation) => {\n                  return op(choicesOrigins);\n                }, []), publishReplay(1), refCount());\n  }\n\n  private _initAttachmentsOriginsStreams(): void {\n    this._attachmentsOrigins = this._attachmentsOriginsUpdates.pipe(\n        scan(\n            (attachmentsOrigins: AjfAttachmentsOrigin<any>[],\n             op: AjfAttachmentsOriginsOperation) => {\n              return op(attachmentsOrigins);\n            },\n            []),\n        publishReplay(1),\n        refCount(),\n    );\n  }\n\n  private _initStringIdentifierStreams(): void {\n    this._stringIdentifier = this._stringIdentifierUpdates.pipe(\n        scan(\n            (stringIdentifier: AjfFormStringIdentifier[], op: AjfFormStringIdentifierOperation) => {\n              return op(stringIdentifier);\n            },\n            []),\n        publishReplay(1),\n        refCount(),\n    );\n  }\n\n  private _initNodesStreams(): void {\n    this._nodes = (<Observable<AjfNodesOperation>>this._nodesUpdates)\n                      .pipe(\n                          scan(\n                              (nodes: AjfNode[], op: AjfNodesOperation) => {\n                                return op(nodes);\n                              },\n                              []),\n                          publishReplay(1),\n                          refCount(),\n                      );\n\n    this._nodesWithoutChoiceOrigins =\n        (this._nodes as Observable<AjfSlide[]>).pipe(map(slides => slides.map(slide => {\n          slide.nodes = (slide.nodes as AjfField[]).map((node: AjfField) => {\n            if (isFieldWithChoices(node)) {\n              const fwc = deepCopy(node);\n              if (fwc && fwc.choices) {\n                delete fwc.choices;\n              }\n              if (fwc && fwc.choicesOrigin) {\n                delete fwc.choicesOrigin;\n              }\n              return fwc;\n            }\n            return node;\n          });\n          return slide;\n        })));\n\n    this._flatNodes = this._nodes.pipe(\n        map((nodes: AjfNode[]) => flattenNodes(nodes)), publishReplay(1), refCount());\n\n    this._flatFields = this._flatNodes.pipe(\n        map((nodes: AjfNode[]) => <AjfField[]>nodes.filter(n => !isContainerNode(n))),\n        publishReplay(1), refCount());\n\n    this._nodeEntriesTree = this._nodes.pipe(\n        map(nodes => <AjfFormBuilderNodeEntry[]>this._buildFormBuilderNodesTree(nodes)),\n        publishReplay(1),\n        refCount(),\n    );\n  }\n\n  private _initSaveNode(): void {\n    this._saveNodeEntryEvent\n        .pipe(\n            withLatestFrom(this.editedNodeEntry, this.choicesOrigins, this.attachmentsOrigins),\n            filter(([_, nodeEntry]) => nodeEntry != null),\n            map(([properties, ne]) => {\n              this._beforeNodesUpdate.emit();\n              const nodeEntry = ne as AjfFormBuilderNodeEntry;\n              const origNode = nodeEntry.node;\n              const node = deepCopy(origNode);\n              node.id = nodeEntry.node.id;\n              node.name = properties.name;\n              node.label = properties.label;\n              node.visibility = properties.visibility != null ?\n                  createCondition({condition: properties.visibility}) :\n                  null;\n\n              const oldConditionalBranches = node.conditionalBranches.length;\n              node.conditionalBranches = properties.conditionalBranches != null ?\n                  properties.conditionalBranches.map(\n                      (condition: string) => createCondition({condition})) :\n                  [alwaysCondition()];\n              const newConditionalBranches = node.conditionalBranches.length;\n\n              if (isRepeatingContainerNode(node)) {\n                const repNode = <AjfRepeatingContainerNode>node;\n                repNode.formulaReps = properties.formulaReps != null ?\n                    createFormula({formula: properties.formulaReps}) :\n                    undefined;\n                repNode.minReps = properties.minReps;\n                repNode.maxReps = properties.maxReps;\n              }\n\n              if (isField(node)) {\n                const field = node as AjfField;\n                field.description = properties.description;\n                field.defaultValue = properties.defaultValue;\n                field.formula = properties.formula != null ?\n                    createFormula({formula: properties.formula}) :\n                    undefined;\n                const forceValue = properties.value;\n                const notEmpty = properties.notEmpty;\n                const validationConditions = properties.validationConditions;\n                let minValue: number|null = parseInt(properties.minValue, 10);\n                let maxValue: number|null = parseInt(properties.maxValue, 10);\n                let minDigits: number|null = parseInt(properties.minDigits, 10);\n                let maxDigits: number|null = parseInt(properties.maxDigits, 10);\n                if (isNaN(minValue)) {\n                  minValue = null;\n                }\n                if (isNaN(maxValue)) {\n                  maxValue = null;\n                }\n                if (isNaN(minDigits)) {\n                  minDigits = null;\n                }\n                if (isNaN(maxDigits)) {\n                  maxDigits = null;\n                }\n                if (forceValue != null || notEmpty != null ||\n                    (validationConditions != null && validationConditions.length > 0) ||\n                    minValue != null || maxValue != null || minDigits != null ||\n                    maxDigits != null) {\n                  const validation = field.validation || createValidationGroup({});\n                  validation.forceValue = forceValue;\n                  validation.notEmpty = notEmpty ? notEmptyValidation() : undefined;\n                  validation.minValue = minValue != null ? minValidation(minValue) : undefined;\n                  validation.maxValue = maxValue != null ? maxValidation(maxValue) : undefined;\n                  validation.minDigits =\n                      minDigits != null ? minDigitsValidation(minDigits) : undefined;\n                  validation.maxDigits =\n                      maxDigits != null ? maxDigitsValidation(maxDigits) : undefined;\n                  validation.conditions =\n                      (validationConditions ||\n                       []).map((c: {condition: string, errorMessage: string}) => createValidation({\n                                 condition: c.condition,\n                                 errorMessage: c.errorMessage\n                               }));\n                  field.validation = validation;\n                } else {\n                  field.validation = undefined;\n                }\n                const notEmptyWarn = properties.notEmptyWarning;\n                const warningConditions = properties.warningConditions;\n                if (notEmptyWarn != null ||\n                    (warningConditions != null && warningConditions.length > 0)) {\n                  const warning = field.warning || createWarningGroup({});\n                  warning.notEmpty = notEmptyWarn ? notEmptyWarning() : undefined;\n                  warning.conditions =\n                      (warningConditions ||\n                       []).map((w: {condition: string, warningMessage: string}) => createWarning({\n                                 condition: w.condition,\n                                 warningMessage: w.warningMessage\n                               }));\n                  field.warning = warning;\n                } else {\n                  field.warning = undefined;\n                }\n                field.nextSlideCondition = properties.nextSlideCondition != null ?\n                    createCondition({condition: properties.nextSlideCondition}) :\n                    undefined;\n                field.size = properties.size;\n                field.defaultValue = properties.defaultValue;\n\n                if (isFieldWithChoices(field)) {\n                  const fwc = <AjfFieldWithChoices<any>>field;\n                  (fwc as any).choicesOriginRef = properties.choicesOriginRef;\n                  fwc.forceExpanded = properties.forceExpanded;\n                  fwc.forceNarrow = properties.forceNarrow;\n                  fwc.triggerConditions = (properties.triggerConditions ||\n                                           []).map((t: string) => createCondition({condition: t}));\n                }\n              }\n\n              this._editedNodeEntry.next(null);\n\n              return (nodes: AjfNode[]): AjfNode[] => {\n                let cn = getNodeContainer({nodes}, origNode);\n                if (cn != null) {\n                  // TODO: @trik check this, was always true?\n                  // if (cn instanceof AjfNode) {\n                  const replaceNodes = cn.nodes === nodes;\n                  const idx = cn.nodes.indexOf(origNode);\n                  let newNodes = cn.nodes.slice(0, idx);\n                  newNodes.push(node);\n                  newNodes = newNodes.concat(cn.nodes.slice(idx + 1));\n                  cn.nodes = newNodes;\n                  if (replaceNodes) {\n                    nodes = newNodes;\n                  } else {\n                    nodes = nodes.slice(0);\n                  }\n                  // } else {\n                  //   const idx = nodes.indexOf(origNode);\n                  //   nodes = nodes.slice(0, idx).concat([node]).concat(nodes.slice(idx + 1));\n                  // }\n                  if (newConditionalBranches < oldConditionalBranches) {\n                    for (let i = newConditionalBranches; i < oldConditionalBranches; i++) {\n                      nodes = deleteNodeSubtree(nodes, node, i);\n                    }\n                  }\n                }\n                return nodes;\n              };\n            }),\n            )\n        .subscribe(this._nodesUpdates);\n  }\n\n  private _initDeleteNode(): void {\n    (<Observable<AjfFormBuilderNodeEntry>>this._deleteNodeEntryEvent)\n        .pipe(map((nodeEntry: AjfFormBuilderNodeEntry) => {\n          this._beforeNodesUpdate.emit();\n          return (nodes: AjfNode[]): AjfNode[] => {\n            const node = nodeEntry.node;\n            let cn = getNodeContainer({nodes}, node);\n            if (cn != null) {\n              const replaceNodes = cn.nodes === nodes;\n              const idx = cn.nodes.indexOf(node);\n              let newNodes = cn.nodes.slice(0, idx);\n              newNodes = newNodes.concat(cn.nodes.slice(idx + 1));\n              cn.nodes = newNodes;\n              if (replaceNodes) {\n                nodes = newNodes;\n              } else {\n                nodes = nodes.slice(0);\n              }\n            }\n            return nodes;\n          };\n        }))\n        .subscribe(this._nodesUpdates);\n  }\n\n  /**\n   * Initializes the subscription to the moveNodeEntryEvent.\n   */\n  private _initMoveNode(): void {\n    this._moveNodeSub.unsubscribe();\n    this._moveNodeSub =\n        this._moveNodeEntryEvent\n            .pipe(\n                map((moveEvent: AjfFormBuilderMoveEvent) => {\n                  this._beforeNodesUpdate.emit();\n                  return (nodes: AjfNode[]): AjfNode[] => {\n                    const nodeEntry = moveEvent.nodeEntry as AjfFormBuilderNodeEntry;\n                    const node = nodeEntry.node;\n                    let cn = getNodeContainer({nodes}, node) as AjfContainerNode;\n                    let newNodes: AjfNode[] = nodes;\n                    if (cn != null) {\n                      const replaceNodes = cn.nodes === nodes;\n                      newNodes = cn.nodes;\n                      moveItemInArray(newNodes, moveEvent.fromIndex, moveEvent.toIndex);\n                      newNodes = this._updateNodesList(cn.id, newNodes);\n                      cn.nodes = newNodes;\n                      if (replaceNodes) {\n                        nodes = newNodes;\n                      } else {\n                        nodes = nodes.slice(0);\n                      }\n                    }\n                    return nodes;\n                  };\n                }),\n                )\n            .subscribe(this._nodesUpdates);\n  }\n\n  /**\n   * Updates the \"id\" and \"parent\" fields of a modified or rearranged list of nodes.\n   * @param containerId The id of the parent container of the list.\n   * @param nodesList The list of nodes to be updated.\n   */\n  private _updateNodesList(containerId: number, nodesList: AjfNode[]): AjfNode[] {\n    if (!nodesList.length) {\n      return [];\n    }\n    const contId = containerId != undefined ? containerId : 0;\n    for (let idx = 0; idx < nodesList.length; idx++) {\n      let currentNode = nodesList[idx];\n      currentNode.id = (contId * 1000) + idx + 1;\n      currentNode.parent = idx == 0 ? contId : (contId * 1000) + idx;\n      if (currentNode.nodeType == AjfNodeType.AjfSlide ||\n          currentNode.nodeType == AjfNodeType.AjfRepeatingSlide) {\n        const currentSlide = currentNode as AjfSlide;\n        if (currentSlide.nodes) {\n          this._updateNodesList(currentSlide.id, currentSlide.nodes);\n        }\n      }\n    }\n    return nodesList;\n  }\n}\n"]}