@ajf/material 15.3.14 → 16.0.1

package/esm2022/form-builder/form-builder-service.mjs

@@ -0,0 +1,923 @@
+/**
+ * @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, isRangeField, isRepeatingContainerNode, isSlidesNode, isTableField, 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, of as obsOf, Subject, Subscription } from 'rxjs';
+import { filter, map, shareReplay, scan, withLatestFrom } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+function getNodeContainer(c, node) {
+    if (c.nodes.indexOf(node) > -1 || c.nodes.map(n => n.id).indexOf(node?.id) > -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 getDefaultValue(value, node) {
+    let defaultValue = value && value.trim() != '' ? value : null;
+    if (defaultValue) {
+        switch (node.fieldType) {
+            case AjfFieldType.Boolean:
+                return defaultValue === 'true' || defaultValue === '1';
+            case AjfFieldType.MultipleChoice:
+                return [defaultValue];
+            case AjfFieldType.Number:
+                const v = +defaultValue;
+                return isNaN(v) ? 0 : v;
+        }
+    }
+    return defaultValue;
+}
+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 {
+    /**
+     * 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 nodeEntriesTreeExpandedStatus() {
+        return this._nodeEntriesTreeExpandedStatus;
+    }
+    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;
+    }
+    constructor() {
+        this._availableNodeTypes = [
+            {
+                label: 'Slide',
+                nodeType: { node: AjfNodeType.AjfSlide },
+                isSlide: true,
+            },
+            {
+                label: 'Repeating slide',
+                nodeType: { node: AjfNodeType.AjfRepeatingSlide },
+                isSlide: true,
+            },
+            {
+                label: 'String',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.String },
+            },
+            {
+                label: 'Text',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Text },
+            },
+            {
+                label: 'Number',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Number },
+            },
+            {
+                label: 'Boolean',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Boolean },
+            },
+            {
+                label: 'Single choice',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.SingleChoice },
+            },
+            {
+                label: 'Multiple choice',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.MultipleChoice },
+            },
+            {
+                label: 'Formula',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Formula },
+            },
+            {
+                label: 'Date',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Date },
+            },
+            {
+                label: 'Date input',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.DateInput },
+            },
+            {
+                label: 'Time',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Time },
+            },
+            {
+                label: 'Table',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Table },
+            },
+            {
+                label: 'Geolocation',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Geolocation },
+            },
+            {
+                label: 'Barcode',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Barcode },
+            },
+            {
+                label: 'Signature',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Signature },
+            },
+            {
+                label: 'File',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.File },
+            },
+            {
+                label: 'Image',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Image },
+            },
+            {
+                label: 'Range',
+                nodeType: { node: AjfNodeType.AjfField, field: AjfFieldType.Range },
+            },
+        ];
+        this._form = new BehaviorSubject(null);
+        this._formObs = this._form;
+        this._attachmentsOrigins = obsOf([]);
+        this._choicesOrigins = obsOf([]);
+        this._stringIdentifier = obsOf([]);
+        this._nodesWithoutChoiceOrigins = obsOf([]);
+        this._nodes = obsOf([]);
+        this._flatFields = obsOf([]);
+        this._nodeEntriesTree = obsOf([]);
+        /**
+         * A list of the ids of the dropLists connected to the source list.
+         */
+        this._connectedDropLists = new BehaviorSubject([]);
+        /**
+         * A dictionary of the 'expanded' status of all nodeEntries in the tree {node.name: boolean}
+         */
+        this._nodeEntriesTreeExpandedStatus = new BehaviorSubject({});
+        /**
+         * Determines the default expanded state of nodeEntries when the FormBuilder loads
+         */
+        this._defaultExpanded = false;
+        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;
+        /**
+         * Counters for default name assigned to inserted fields/slides
+         */
+        this._emptyFieldCounter = 1;
+        this._emptySlideCounter = 1;
+        this._initChoicesOriginsStreams();
+        this._initAttachmentsOriginsStreams();
+        this._initStringIdentifierStreams();
+        this._initNodesStreams();
+        this._initFormStreams();
+        this._initSaveNode();
+        this._initMoveNode();
+        this._initDeleteNode();
+    }
+    /**
+     * 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) {
+        let node;
+        const id = ++nodeUniqueId;
+        const isFieldNode = nodeType.nodeType?.field != null;
+        if (isFieldNode) {
+            node = createField({
+                id,
+                nodeType: AjfNodeType.AjfField,
+                fieldType: nodeType.nodeType.field,
+                parent: parent.id,
+                parentNode,
+                name: `new_field_${this._emptyFieldCounter}`,
+                label: `New ${AjfFieldType[nodeType.nodeType.field]} field ${this._emptyFieldCounter}`,
+            });
+            this._emptyFieldCounter++;
+        }
+        else {
+            node = createContainerNode({
+                id,
+                nodeType: nodeType.nodeType.node,
+                parent: 0,
+                parentNode,
+                name: `new_slide_${this._emptySlideCounter}`,
+                label: `New Slide ${this._emptySlideCounter}`,
+                nodes: [],
+            });
+            this._emptySlideCounter++;
+        }
+        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;
+        });
+        this.cancelNodeEntryEdit();
+    }
+    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);
+        this.cancelNodeEntryEdit();
+    }
+    getCurrentForm() {
+        return combineLatest([
+            this.form,
+            this._nodesWithoutChoiceOrigins,
+            this.attachmentsOrigins,
+            this.choicesOrigins,
+            this.stringIdentifier,
+        ]).pipe(filter(([form]) => form != null), map(([form, nodes, attachmentsOrigins, choicesOrigins, stringIdentifier]) => {
+            const supplementaryInformations = (form || {}).supplementaryInformations;
+            return createForm({
+                choicesOrigins: [...choicesOrigins],
+                attachmentsOrigins: [...attachmentsOrigins],
+                stringIdentifier: [...(stringIdentifier || [])],
+                nodes: [...nodes],
+                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();
+        const choicesOriginPreviousName = choicesOrigin?.name;
+        if (choicesOrigin != null) {
+            choicesOrigin.label = params.label;
+            choicesOrigin.name = params.name;
+            if (isChoicesFixedOrigin(choicesOrigin)) {
+                choicesOrigin.choices = params.choices;
+            }
+            this._updateChoicesOriginRefInNodes(choicesOriginPreviousName, params.name);
+            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]);
+    }
+    /**
+     * Resets the nodeEntriesTreeExpandedStatus dictionary to an empty object.
+     */
+    resetNodeEntriesTreeExpandedStatus() {
+        this._nodeEntriesTreeExpandedStatus.next({});
+    }
+    /**
+     * Gets the expanded status of an entry in the nodeEntriesTreeExpandedStatus dictionary
+     * @param nodeName The unique name of the nodeEntry
+     */
+    getExpandedStatus(nodeName) {
+        return this._nodeEntriesTreeExpandedStatus.pipe(map(tree => {
+            if (nodeName in tree) {
+                return tree[nodeName];
+            }
+            return this._defaultExpanded;
+        }));
+    }
+    /**
+     * Upserts an entry in the nodeEntriesTreeExpandedStatus dictionary
+     * @param nodeName The unique name of the nodeEntry
+     * @param expanded True if the nodeEntry is expanded
+     */
+    updateExpandedStatus(nodeName, expanded) {
+        if (!nodeName)
+            return;
+        const dictValue = this._nodeEntriesTreeExpandedStatus.value;
+        this._nodeEntriesTreeExpandedStatus.next({ ...dictValue, [nodeName]: expanded });
+    }
+    /**
+     * Removes an entry from the nodeEntriesTreeExpandedStatus dictionary
+     * @param nodeName The unique name of the nodeEntry
+     */
+    removeExpandedStatus(nodeName) {
+        const dictValue = this._nodeEntriesTreeExpandedStatus.value;
+        delete dictValue[nodeName];
+        this._nodeEntriesTreeExpandedStatus.next(dictValue);
+    }
+    /**
+     * Sets expanded to true for each entry in the nodeEntriesTreeExpandedStatus dictionary
+     */
+    expandAll() {
+        const dictValue = this._nodeEntriesTreeExpandedStatus.value;
+        for (let nodeName in dictValue) {
+            dictValue[nodeName] = true;
+        }
+        this._defaultExpanded = true;
+        this._nodeEntriesTreeExpandedStatus.next(dictValue);
+    }
+    /**
+     * Sets expanded to false for each entry in the nodeEntriesTreeExpandedStatus dictionary
+     */
+    collapseAll() {
+        const dictValue = this._nodeEntriesTreeExpandedStatus.value;
+        for (let nodeName in dictValue) {
+            dictValue[nodeName] = false;
+        }
+        this._defaultExpanded = false;
+        this._nodeEntriesTreeExpandedStatus.next(dictValue);
+    }
+    /**
+     * Resets the empty fields/slides counters
+     */
+    resetEmptyCounters() {
+        this._emptyFieldCounter = 1;
+        this._emptySlideCounter = 1;
+    }
+    /**
+     * Searches the form nodes for field nodes with choicesOriginRef corresponding
+     * to an edited choicesOrigin and updates it with the new name.
+     * @param previous_name The choicesOrigin previous name
+     * @param new_name The choicesOrigin new name
+     */
+    _updateChoicesOriginRefInNodes(previous_name, new_name) {
+        if (!previous_name || !new_name)
+            return;
+        const currentForm = this._form.value;
+        if (!currentForm)
+            return;
+        const updatedNodes = [];
+        const currentSlides = currentForm.nodes;
+        for (let slide of currentSlides) {
+            if (!slide.nodes || !slide.nodes.length)
+                continue;
+            for (let node of slide.nodes) {
+                const nodeObj = node;
+                if (nodeObj['choicesOriginRef'] && nodeObj['choicesOriginRef'] === previous_name) {
+                    nodeObj['choicesOriginRef'] = new_name;
+                    updatedNodes.push(nodeObj);
+                }
+            }
+        }
+        this._nodesUpdates.next((_nodes) => {
+            return currentForm.nodes.slice(0);
+        });
+    }
+    _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);
+        }, []), shareReplay(1));
+    }
+    _initAttachmentsOriginsStreams() {
+        this._attachmentsOrigins = this._attachmentsOriginsUpdates.pipe(scan((attachmentsOrigins, op) => {
+            return op(attachmentsOrigins);
+        }, []), shareReplay(1));
+    }
+    _initStringIdentifierStreams() {
+        this._stringIdentifier = this._stringIdentifierUpdates.pipe(scan((stringIdentifier, op) => {
+            return op(stringIdentifier);
+        }, []), shareReplay(1));
+    }
+    _initNodesStreams() {
+        this._nodes = this._nodesUpdates.pipe(scan((nodes, op) => {
+            return op(nodes);
+        }, []), shareReplay(1));
+        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)), shareReplay(1));
+        this._flatFields = this._flatNodes.pipe(map((nodes) => nodes.filter(n => !isContainerNode(n))), shareReplay(1));
+        this._nodeEntriesTree = this._nodes.pipe(map(nodes => this._buildFormBuilderNodesTree(nodes)), shareReplay(1));
+    }
+    _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)) {
+                node.formulaReps =
+                    properties.formulaReps != null
+                        ? createFormula({ formula: properties.formulaReps })
+                        : undefined;
+                node.minReps = properties.minReps;
+                node.maxReps = properties.maxReps;
+            }
+            if (isField(node)) {
+                node.hint = properties.hint;
+                node.editable = !properties.readonlyField;
+                node.description = properties.description;
+                node.defaultValue = getDefaultValue(properties.defaultValue, node);
+                node.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 = node.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,
+                    }));
+                    node.validation = validation;
+                }
+                else {
+                    node.validation = undefined;
+                }
+                const notEmptyWarn = properties.notEmptyWarning;
+                const warningConditions = properties.warningConditions;
+                if (notEmptyWarn != null ||
+                    (warningConditions != null && warningConditions.length > 0)) {
+                    const warning = node.warning || createWarningGroup({});
+                    warning.notEmpty = notEmptyWarn ? notEmptyWarning() : undefined;
+                    warning.conditions = (warningConditions || []).map((w) => createWarning({
+                        condition: w.condition,
+                        warningMessage: w.warningMessage,
+                    }));
+                    node.warning = warning;
+                }
+                else {
+                    node.warning = undefined;
+                }
+                node.nextSlideCondition =
+                    properties.nextSlideCondition != null
+                        ? createCondition({ condition: properties.nextSlideCondition })
+                        : undefined;
+                node.size = properties.size;
+                if (isFieldWithChoices(node)) {
+                    node.choicesOriginRef = properties.choicesOriginRef;
+                    node.forceExpanded = properties.forceExpanded;
+                    node.forceNarrow = properties.forceNarrow;
+                    node.triggerConditions = (properties.triggerConditions || []).map((t) => createCondition({ condition: t }));
+                }
+                if (isRangeField(node)) {
+                    node.start = properties.start;
+                    node.end = properties.end;
+                    node.step = properties.step;
+                }
+                if (isTableField(node)) {
+                    let { columnTypes, rows, columnLabels, rowLabels } = JSON.parse(properties.tableDef);
+                    node.columnTypes = columnTypes || [];
+                    node.rows = rows || [];
+                    node.columnLabels = columnLabels || [];
+                    node.rowLabels = rowLabels || [];
+                    node.hideEmptyRows = properties.hideEmptyRows;
+                }
+            }
+            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.map(n => n.id).indexOf(origNode.id);
+                    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();
+            this.removeExpandedStatus(nodeEntry.node.name);
+            return (nodes) => {
+                const node = nodeEntry.node;
+                let cn = getNodeContainer({ nodes }, node);
+                if (cn != null) {
+                    const replaceNodes = cn.nodes === nodes;
+                    const idx = cn.nodes.map(n => n.id).indexOf(node.id);
+                    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 (isSlidesNode(currentNode)) {
+                this._updateNodesList(currentNode.id, currentNode.nodes);
+            }
+        }
+        return nodesList;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AjfFormBuilderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AjfFormBuilderService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AjfFormBuilderService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-builder-service.js","sourceRoot":"","sources":["../../../../projects/material/form-builder/src/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  AjfForm,\n  AjfFormStringIdentifier,\n  AjfNode,\n  AjfNodeGroup,\n  AjfNodesOperation,\n  AjfNodeType,\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  isRangeField,\n  isRepeatingContainerNode,\n  isSlidesNode,\n  isTableField,\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, of as obsOf, Subject, Subscription} from 'rxjs';\nimport {filter, map, shareReplay, scan, withLatestFrom} from 'rxjs/operators';\n\nimport {\n  AjfAttachmentsOriginsOperation,\n  AjfChoicesOriginsOperation,\n  AjfFormStringIdentifierOperation,\n} from './operations';\n\nexport interface AjfFormBuilderNodeTypeEntry {\n  label: string;\n  nodeType: {node: AjfNodeType; field?: AjfFieldType};\n  isSlide?: boolean;\n}\n\nexport interface AjfFormBuilderNodeEntry {\n  node: AjfNode;\n  container: AjfContainerNode | null;\n  children: AjfFormBuilderNodeEntry[];\n  content: AjfFormBuilderNodeEntry[];\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\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 || c.nodes.map(n => n.id).indexOf(node?.id) > -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 getDefaultValue(\n  value: any,\n  node: AjfField<any>,\n): string | string[] | number | boolean | null {\n  let defaultValue = value && (value as string).trim() != '' ? (value as string) : null;\n  if (defaultValue) {\n    switch (node.fieldType) {\n      case AjfFieldType.Boolean:\n        return defaultValue === 'true' || defaultValue === '1';\n      case AjfFieldType.MultipleChoice:\n        return [defaultValue];\n      case AjfFieldType.Number:\n        const v = +defaultValue;\n        return isNaN(v) ? 0 : v;\n    }\n  }\n  return defaultValue;\n}\n\nfunction buildFormBuilderNodesSubtree(\n  nodes: AjfNode[],\n  parent: AjfNode,\n  ignoreConditionalBranches = false,\n): AjfFormBuilderNode[] {\n  const entries: AjfFormBuilderNode[] = nodes\n    .filter(n => n.parent === parent.id)\n    .sort((n1, n2) => n1.parentNode - n2.parentNode)\n    .map(n => {\n      const children = 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[],\n  parentNode: AjfNode,\n  branch: number | null = null,\n): 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[],\n  parentNode: AjfNode,\n  branch: number | null = null,\n): 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(\n    nodes,\n    delNodes.map(n => n.id),\n  );\n}\n\nlet nodeUniqueId = 0;\n\n@Injectable()\nexport class AjfFormBuilderService {\n  private _availableNodeTypes: AjfFormBuilderNodeTypeEntry[] = [\n    {\n      label: 'Slide',\n      nodeType: {node: AjfNodeType.AjfSlide},\n      isSlide: true,\n    },\n    {\n      label: 'Repeating slide',\n      nodeType: {node: AjfNodeType.AjfRepeatingSlide},\n      isSlide: true,\n    },\n    {\n      label: 'String',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.String},\n    },\n    {\n      label: 'Text',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Text},\n    },\n    {\n      label: 'Number',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Number},\n    },\n    {\n      label: 'Boolean',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Boolean},\n    },\n    {\n      label: 'Single choice',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.SingleChoice},\n    },\n    {\n      label: 'Multiple choice',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.MultipleChoice},\n    },\n    {\n      label: 'Formula',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Formula},\n    },\n    {\n      label: 'Date',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Date},\n    },\n    {\n      label: 'Date input',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.DateInput},\n    },\n    {\n      label: 'Time',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Time},\n    },\n    {\n      label: 'Table',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Table},\n    },\n    {\n      label: 'Geolocation',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Geolocation},\n    },\n    {\n      label: 'Barcode',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Barcode},\n    },\n    {\n      label: 'Signature',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Signature},\n    },\n    {\n      label: 'File',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.File},\n    },\n    {\n      label: 'Image',\n      nodeType: {node: AjfNodeType.AjfField, field: AjfFieldType.Image},\n    },\n    {\n      label: '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>[]> = obsOf([]);\n  get attachmentsOrigins(): Observable<AjfAttachmentsOrigin<any>[]> {\n    return this._attachmentsOrigins;\n  }\n\n  private _choicesOrigins: Observable<AjfChoicesOrigin<any>[]> = obsOf([]);\n  get choicesOrigins(): Observable<AjfChoicesOrigin<any>[]> {\n    return this._choicesOrigins;\n  }\n\n  private _stringIdentifier: Observable<AjfFormStringIdentifier[]> = obsOf([]);\n  get stringIdentifier(): Observable<AjfFormStringIdentifier[]> {\n    return this._stringIdentifier;\n  }\n\n  private _nodesWithoutChoiceOrigins: Observable<AjfSlide[]> = obsOf([]);\n  private _nodes: Observable<AjfNode[]> = obsOf([]);\n  get nodes(): Observable<AjfNode[]> {\n    return this._nodes;\n  }\n\n  private _flatNodes: Observable<AjfNode[]> | undefined;\n  get flatNodes(): Observable<AjfNode[]> | undefined {\n    return this._flatNodes;\n  }\n\n  private _flatFields: Observable<AjfField[]> = obsOf([]);\n  get flatFields(): Observable<AjfField[]> {\n    return this._flatFields;\n  }\n\n  private _nodeEntriesTree: Observable<AjfFormBuilderNodeEntry[]> = obsOf([]);\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  /**\n   * A dictionary of the 'expanded' status of all nodeEntries in the tree {node.name: boolean}\n   */\n  private _nodeEntriesTreeExpandedStatus: BehaviorSubject<{[name: string]: boolean}> =\n    new BehaviorSubject<{[name: string]: boolean}>({});\n  get nodeEntriesTreeExpandedStatus(): BehaviorSubject<{[name: string]: boolean}> {\n    return this._nodeEntriesTreeExpandedStatus;\n  }\n\n  /**\n   * Determines the default expanded state of nodeEntries when the FormBuilder loads\n   */\n  private _defaultExpanded: boolean = false;\n\n  private _editedNodeEntry: BehaviorSubject<AjfFormBuilderNodeEntry | null> =\n    new BehaviorSubject<AjfFormBuilderNodeEntry | null>(null);\n  private _editedNodeEntryObs: Observable<AjfFormBuilderNodeEntry | null> = this\n    ._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> = this\n    ._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> = this\n    ._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  /**\n   * Counters for default name assigned to inserted fields/slides\n   */\n  private _emptyFieldCounter: number = 1;\n  private _emptySlideCounter: number = 1;\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,\n    parent: AjfNode,\n    parentNode: number,\n    inContent = false,\n    insertInIndex = 0,\n  ): 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: `new_field_${this._emptyFieldCounter}`,\n        label: `New ${AjfFieldType[nodeType.nodeType.field!]} field ${this._emptyFieldCounter}`,\n      });\n      this._emptyFieldCounter++;\n    } else {\n      node = createContainerNode({\n        id,\n        nodeType: nodeType.nodeType.node,\n        parent: 0,\n        parentNode,\n        name: `new_slide_${this._emptySlideCounter}`,\n        label: `New Slide ${this._emptySlideCounter}`,\n        nodes: [],\n      });\n      this._emptySlideCounter++;\n    }\n    this._beforeNodesUpdate.emit();\n    this._nodesUpdates.next((nodes: AjfNode[]): AjfNode[] => {\n      const cn =\n        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    this.cancelNodeEntryEdit();\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    this.cancelNodeEntryEdit();\n  }\n\n  getCurrentForm(): Observable<AjfForm> {\n    return combineLatest([\n      this.form,\n      this._nodesWithoutChoiceOrigins,\n      this.attachmentsOrigins,\n      this.choicesOrigins,\n      this.stringIdentifier,\n    ]).pipe(\n      filter(([form]) => form != null),\n      map(([form, nodes, attachmentsOrigins, choicesOrigins, stringIdentifier]) => {\n        const supplementaryInformations = (form || {}).supplementaryInformations;\n        return createForm({\n          choicesOrigins: [...choicesOrigins],\n          attachmentsOrigins: [...attachmentsOrigins],\n          stringIdentifier: [...(stringIdentifier || [])],\n          nodes: [...nodes],\n          supplementaryInformations,\n        });\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    const choicesOriginPreviousName: string | undefined = choicesOrigin?.name;\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._updateChoicesOriginRefInNodes(choicesOriginPreviousName, params.name);\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  /**\n   * Resets the nodeEntriesTreeExpandedStatus dictionary to an empty object.\n   */\n  resetNodeEntriesTreeExpandedStatus(): void {\n    this._nodeEntriesTreeExpandedStatus.next({});\n  }\n\n  /**\n   * Gets the expanded status of an entry in the nodeEntriesTreeExpandedStatus dictionary\n   * @param nodeName The unique name of the nodeEntry\n   */\n  getExpandedStatus(nodeName: string): Observable<boolean> {\n    return this._nodeEntriesTreeExpandedStatus.pipe(\n      map(tree => {\n        if (nodeName in tree) {\n          return tree[nodeName];\n        }\n        return this._defaultExpanded;\n      }),\n    );\n  }\n\n  /**\n   * Upserts an entry in the nodeEntriesTreeExpandedStatus dictionary\n   * @param nodeName The unique name of the nodeEntry\n   * @param expanded True if the nodeEntry is expanded\n   */\n  updateExpandedStatus(nodeName: string, expanded: boolean): void {\n    if (!nodeName) return;\n    const dictValue = this._nodeEntriesTreeExpandedStatus.value;\n    this._nodeEntriesTreeExpandedStatus.next({...dictValue, [nodeName]: expanded});\n  }\n\n  /**\n   * Removes an entry from the nodeEntriesTreeExpandedStatus dictionary\n   * @param nodeName The unique name of the nodeEntry\n   */\n  removeExpandedStatus(nodeName: string): void {\n    const dictValue = this._nodeEntriesTreeExpandedStatus.value;\n    delete dictValue[nodeName];\n    this._nodeEntriesTreeExpandedStatus.next(dictValue);\n  }\n\n  /**\n   * Sets expanded to true for each entry in the nodeEntriesTreeExpandedStatus dictionary\n   */\n  expandAll() {\n    const dictValue = this._nodeEntriesTreeExpandedStatus.value;\n    for (let nodeName in dictValue) {\n      dictValue[nodeName] = true;\n    }\n    this._defaultExpanded = true;\n    this._nodeEntriesTreeExpandedStatus.next(dictValue);\n  }\n\n  /**\n   * Sets expanded to false for each entry in the nodeEntriesTreeExpandedStatus dictionary\n   */\n  collapseAll() {\n    const dictValue = this._nodeEntriesTreeExpandedStatus.value;\n    for (let nodeName in dictValue) {\n      dictValue[nodeName] = false;\n    }\n    this._defaultExpanded = false;\n    this._nodeEntriesTreeExpandedStatus.next(dictValue);\n  }\n\n  /**\n   * Resets the empty fields/slides counters\n   */\n  resetEmptyCounters() {\n    this._emptyFieldCounter = 1;\n    this._emptySlideCounter = 1;\n  }\n\n  /**\n   * Searches the form nodes for field nodes with choicesOriginRef corresponding\n   * to an edited choicesOrigin and updates it with the new name.\n   * @param previous_name The choicesOrigin previous name\n   * @param new_name The choicesOrigin new name\n   */\n  private _updateChoicesOriginRefInNodes(previous_name?: string, new_name?: string): void {\n    if (!previous_name || !new_name) return;\n    const currentForm: AjfForm | null = this._form.value;\n    if (!currentForm) return;\n    const updatedNodes: AjfNode[] = [];\n    const currentSlides: (AjfSlide | AjfRepeatingSlide)[] = currentForm.nodes;\n    for (let slide of currentSlides) {\n      if (!slide.nodes || !slide.nodes.length) continue;\n      for (let node of slide.nodes) {\n        const nodeObj = node as {[key: string]: any};\n        if (nodeObj['choicesOriginRef'] && nodeObj['choicesOriginRef'] === previous_name) {\n          nodeObj['choicesOriginRef'] = new_name;\n          updatedNodes.push(nodeObj as AjfNode);\n        }\n      }\n    }\n    this._nodesUpdates.next((_nodes: AjfNode[]): AjfNode[] => {\n      return currentForm.nodes.slice(0);\n    });\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    );\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      );\n      this._choicesOriginsUpdates.next(\n        (_choicesOrigins: AjfChoicesOrigin<any>[]): AjfChoicesOrigin<any>[] => {\n          return form != null && form.choicesOrigins != null ? form.choicesOrigins.slice(0) : [];\n        },\n      );\n      this._stringIdentifierUpdates.next(\n        (_: AjfFormStringIdentifier[]): AjfFormStringIdentifier[] => {\n          return form != null && form.stringIdentifier != null\n            ? form.stringIdentifier.slice(0)\n            : [];\n        },\n      );\n    });\n  }\n\n  private _initChoicesOriginsStreams(): void {\n    this._choicesOrigins = (<Observable<AjfChoicesOriginsOperation>>(\n      this._choicesOriginsUpdates\n    )).pipe(\n      scan((choicesOrigins: AjfChoicesOrigin<any>[], op: AjfChoicesOriginsOperation) => {\n        return op(choicesOrigins);\n      }, []),\n      shareReplay(1),\n    );\n  }\n\n  private _initAttachmentsOriginsStreams(): void {\n    this._attachmentsOrigins = this._attachmentsOriginsUpdates.pipe(\n      scan(\n        (attachmentsOrigins: AjfAttachmentsOrigin<any>[], op: AjfAttachmentsOriginsOperation) => {\n          return op(attachmentsOrigins);\n        },\n        [],\n      ),\n      shareReplay(1),\n    );\n  }\n\n  private _initStringIdentifierStreams(): void {\n    this._stringIdentifier = this._stringIdentifierUpdates.pipe(\n      scan((stringIdentifier: AjfFormStringIdentifier[], op: AjfFormStringIdentifierOperation) => {\n        return op(stringIdentifier);\n      }, []),\n      shareReplay(1),\n    );\n  }\n\n  private _initNodesStreams(): void {\n    this._nodes = (<Observable<AjfNodesOperation>>this._nodesUpdates).pipe(\n      scan((nodes: AjfNode[], op: AjfNodesOperation) => {\n        return op(nodes);\n      }, []),\n      shareReplay(1),\n    );\n\n    this._nodesWithoutChoiceOrigins = (this._nodes as Observable<AjfSlide[]>).pipe(\n      map(slides =>\n        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    );\n\n    this._flatNodes = this._nodes.pipe(\n      map((nodes: AjfNode[]) => flattenNodes(nodes)),\n      shareReplay(1),\n    );\n\n    this._flatFields = this._flatNodes.pipe(\n      map((nodes: AjfNode[]) => <AjfField[]>nodes.filter(n => !isContainerNode(n))),\n      shareReplay(1),\n    );\n\n    this._nodeEntriesTree = this._nodes.pipe(\n      map(nodes => <AjfFormBuilderNodeEntry[]>this._buildFormBuilderNodesTree(nodes)),\n      shareReplay(1),\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 =\n            properties.visibility != null\n              ? createCondition({condition: properties.visibility})\n              : null;\n\n          const oldConditionalBranches = node.conditionalBranches.length;\n          node.conditionalBranches =\n            properties.conditionalBranches != null\n              ? properties.conditionalBranches.map((condition: string) =>\n                  createCondition({condition}),\n                )\n              : [alwaysCondition()];\n          const newConditionalBranches = node.conditionalBranches.length;\n\n          if (isRepeatingContainerNode(node)) {\n            node.formulaReps =\n              properties.formulaReps != null\n                ? createFormula({formula: properties.formulaReps})\n                : undefined;\n            node.minReps = properties.minReps;\n            node.maxReps = properties.maxReps;\n          }\n\n          if (isField(node)) {\n            node.hint = properties.hint;\n            node.editable = !properties.readonlyField;\n            node.description = properties.description;\n            node.defaultValue = getDefaultValue(properties.defaultValue, node);\n            node.formula =\n              properties.formula != null ? createFormula({formula: properties.formula}) : 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 (\n              forceValue != null ||\n              notEmpty != null ||\n              (validationConditions != null && validationConditions.length > 0) ||\n              minValue != null ||\n              maxValue != null ||\n              minDigits != null ||\n              maxDigits != null\n            ) {\n              const validation = node.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 = minDigits != null ? minDigitsValidation(minDigits) : undefined;\n              validation.maxDigits = maxDigits != null ? maxDigitsValidation(maxDigits) : undefined;\n              validation.conditions = (validationConditions || []).map(\n                (c: {condition: string; errorMessage: string}) =>\n                  createValidation({\n                    condition: c.condition,\n                    errorMessage: c.errorMessage,\n                  }),\n              );\n              node.validation = validation;\n            } else {\n              node.validation = undefined;\n            }\n            const notEmptyWarn = properties.notEmptyWarning;\n            const warningConditions = properties.warningConditions;\n            if (\n              notEmptyWarn != null ||\n              (warningConditions != null && warningConditions.length > 0)\n            ) {\n              const warning = node.warning || createWarningGroup({});\n              warning.notEmpty = notEmptyWarn ? notEmptyWarning() : undefined;\n              warning.conditions = (warningConditions || []).map(\n                (w: {condition: string; warningMessage: string}) =>\n                  createWarning({\n                    condition: w.condition,\n                    warningMessage: w.warningMessage,\n                  }),\n              );\n              node.warning = warning;\n            } else {\n              node.warning = undefined;\n            }\n            node.nextSlideCondition =\n              properties.nextSlideCondition != null\n                ? createCondition({condition: properties.nextSlideCondition})\n                : undefined;\n            node.size = properties.size;\n\n            if (isFieldWithChoices(node)) {\n              (node as any).choicesOriginRef = properties.choicesOriginRef;\n              node.forceExpanded = properties.forceExpanded;\n              node.forceNarrow = properties.forceNarrow;\n              node.triggerConditions = (properties.triggerConditions || []).map((t: string) =>\n                createCondition({condition: t}),\n              );\n            }\n\n            if (isRangeField(node)) {\n              node.start = properties.start;\n              node.end = properties.end;\n              node.step = properties.step;\n            }\n\n            if (isTableField(node)) {\n              let {columnTypes, rows, columnLabels, rowLabels} = JSON.parse(properties.tableDef);\n              node.columnTypes = columnTypes || [];\n              node.rows = rows || [];\n              node.columnLabels = columnLabels || [];\n              node.rowLabels = rowLabels || [];\n              node.hideEmptyRows = properties.hideEmptyRows;\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.map(n => n.id).indexOf(origNode.id);\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(\n        map((nodeEntry: AjfFormBuilderNodeEntry) => {\n          this._beforeNodesUpdate.emit();\n          this.removeExpandedStatus(nodeEntry.node.name);\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.map(n => n.id).indexOf(node.id);\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      )\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 = 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 (isSlidesNode(currentNode)) {\n        this._updateNodesList(currentNode.id, currentNode.nodes);\n      }\n    }\n    return nodesList;\n  }\n}\n"]}