@openmrs/ngx-formentry 3.0.1-pre.100

package/esm2015/form-entry/directives/collapse.directive.js

@@ -0,0 +1,172 @@
+import { AnimationBuilder } from '@angular/animations';
+import { Directive, ElementRef, EventEmitter, HostBinding, Input, Output, Renderer2 } from '@angular/core';
+import { collapseAnimation, expandAnimation } from './collapse-animations';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/animations";
+export class CollapseDirective {
+    constructor(_el, _renderer, _builder) {
+        this._el = _el;
+        this._renderer = _renderer;
+        // @HostBinding('class.collapse')
+        /** This event fires as soon as content collapses */
+        this.collapsed = new EventEmitter();
+        /** This event fires when collapsing is started */
+        this.collapses = new EventEmitter();
+        /** This event fires as soon as content becomes visible */
+        this.expanded = new EventEmitter();
+        /** This event fires when expansion is started */
+        this.expands = new EventEmitter();
+        // shown
+        this.isExpanded = true;
+        this.collapseNewValue = true;
+        // hidden
+        this.isCollapsed = false;
+        // stale state
+        this.isCollapse = true;
+        // animation state
+        this.isCollapsing = false;
+        /** turn on/off animation */
+        this.isAnimated = false;
+        this._display = 'block';
+        this._stylesLoaded = false;
+        this._COLLAPSE_ACTION_NAME = 'collapse';
+        this._EXPAND_ACTION_NAME = 'expand';
+        this._factoryCollapseAnimation = _builder.build(collapseAnimation);
+        this._factoryExpandAnimation = _builder.build(expandAnimation);
+    }
+    set display(value) {
+        if (!this.isAnimated) {
+            this._renderer.setStyle(this._el.nativeElement, 'display', value);
+            return;
+        }
+        this._display = value;
+        if (value === 'none') {
+            this.hide();
+            return;
+        }
+        this.show();
+    }
+    /** A flag indicating visibility of content (shown or hidden) */
+    set collapse(value) {
+        this.collapseNewValue = value;
+        if (!this._player || this._isAnimationDone) {
+            this.isExpanded = value;
+            this.toggle();
+        }
+    }
+    get collapse() {
+        return this.isExpanded;
+    }
+    ngAfterViewChecked() {
+        this._stylesLoaded = true;
+        if (!this._player || !this._isAnimationDone) {
+            return;
+        }
+        this._player.reset();
+        this._renderer.setStyle(this._el.nativeElement, 'height', '*');
+    }
+    /** allows to manually toggle content visibility */
+    toggle() {
+        if (this.isExpanded) {
+            this.hide();
+        }
+        else {
+            this.show();
+        }
+    }
+    /** allows to manually hide content */
+    hide() {
+        this.isCollapsing = true;
+        this.isExpanded = false;
+        this.isCollapsed = true;
+        this.isCollapsing = false;
+        this.collapses.emit(this);
+        this._isAnimationDone = false;
+        this.animationRun(this.isAnimated, this._COLLAPSE_ACTION_NAME)(() => {
+            this._isAnimationDone = true;
+            if (this.collapseNewValue !== this.isCollapsed && this.isAnimated) {
+                this.show();
+                return;
+            }
+            this.collapsed.emit(this);
+            this._renderer.setStyle(this._el.nativeElement, 'display', 'none');
+        });
+    }
+    /** allows to manually show collapsed content */
+    show() {
+        this._renderer.setStyle(this._el.nativeElement, 'display', this._display);
+        this.isCollapsing = true;
+        this.isExpanded = true;
+        this.isCollapsed = false;
+        this.isCollapsing = false;
+        this.expands.emit(this);
+        this._isAnimationDone = false;
+        this.animationRun(this.isAnimated, this._EXPAND_ACTION_NAME)(() => {
+            this._isAnimationDone = true;
+            if (this.collapseNewValue !== this.isCollapsed && this.isAnimated) {
+                this.hide();
+                return;
+            }
+            this.expanded.emit(this);
+            this._renderer.removeStyle(this._el.nativeElement, 'overflow');
+        });
+    }
+    animationRun(isAnimated, action) {
+        if (!isAnimated || !this._stylesLoaded) {
+            return (callback) => callback();
+        }
+        this._renderer.setStyle(this._el.nativeElement, 'overflow', 'hidden');
+        this._renderer.addClass(this._el.nativeElement, 'collapse');
+        const factoryAnimation = action === this._EXPAND_ACTION_NAME
+            ? this._factoryExpandAnimation
+            : this._factoryCollapseAnimation;
+        if (this._player) {
+            this._player.destroy();
+        }
+        this._player = factoryAnimation.create(this._el.nativeElement);
+        this._player.play();
+        return (callback) => { var _a; return (_a = this._player) === null || _a === void 0 ? void 0 : _a.onDone(callback); };
+    }
+}
+CollapseDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CollapseDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.AnimationBuilder }], target: i0.ɵɵFactoryTarget.Directive });
+CollapseDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: CollapseDirective, selector: "[ofeCollapse]", inputs: { display: "display", isAnimated: "isAnimated", collapse: "collapse" }, outputs: { collapsed: "collapsed", collapses: "collapses", expanded: "expanded", expands: "expands" }, host: { properties: { "class.in": "this.isExpanded", "class.show": "this.isExpanded", "attr.aria-expanded": "this.isExpanded", "attr.aria-hidden": "this.isCollapsed", "class.collapse": "this.isCollapse", "class.collapsing": "this.isCollapsing" } }, exportAs: ["bs-collapse"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CollapseDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ofeCollapse]',
+                    exportAs: 'bs-collapse'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.AnimationBuilder }]; }, propDecorators: { collapsed: [{
+                type: Output
+            }], collapses: [{
+                type: Output
+            }], expanded: [{
+                type: Output
+            }], expands: [{
+                type: Output
+            }], isExpanded: [{
+                type: HostBinding,
+                args: ['class.in']
+            }, {
+                type: HostBinding,
+                args: ['class.show']
+            }, {
+                type: HostBinding,
+                args: ['attr.aria-expanded']
+            }], isCollapsed: [{
+                type: HostBinding,
+                args: ['attr.aria-hidden']
+            }], isCollapse: [{
+                type: HostBinding,
+                args: ['class.collapse']
+            }], isCollapsing: [{
+                type: HostBinding,
+                args: ['class.collapsing']
+            }], display: [{
+                type: Input
+            }], isAnimated: [{
+                type: Input
+            }], collapse: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collapse.directive.js","sourceRoot":"","sources":["../../../../../projects/ngx-formentry/src/form-entry/directives/collapse.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AnimationBuilder,\n  AnimationFactory,\n  AnimationPlayer\n} from '@angular/animations';\nimport {\n  AfterViewChecked,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  Input,\n  Output,\n  Renderer2\n} from '@angular/core';\n\nimport { collapseAnimation, expandAnimation } from './collapse-animations';\n\n@Directive({\n  selector: '[ofeCollapse]',\n  exportAs: 'bs-collapse'\n})\nexport class CollapseDirective implements AfterViewChecked {\n  // @HostBinding('class.collapse')\n  /** This event fires as soon as content collapses */\n  @Output() collapsed: EventEmitter<CollapseDirective> = new EventEmitter();\n  /** This event fires when collapsing is started */\n  @Output() collapses: EventEmitter<CollapseDirective> = new EventEmitter();\n  /** This event fires as soon as content becomes visible */\n  @Output() expanded: EventEmitter<CollapseDirective> = new EventEmitter();\n  /** This event fires when expansion is started */\n  @Output() expands: EventEmitter<CollapseDirective> = new EventEmitter();\n  // shown\n  @HostBinding('class.in')\n  @HostBinding('class.show')\n  @HostBinding('attr.aria-expanded')\n  isExpanded = true;\n  collapseNewValue = true;\n  // hidden\n  @HostBinding('attr.aria-hidden') isCollapsed = false;\n  // stale state\n  @HostBinding('class.collapse') isCollapse = true;\n  // animation state\n  @HostBinding('class.collapsing') isCollapsing = false;\n\n  @Input()\n  set display(value: string) {\n    if (!this.isAnimated) {\n      this._renderer.setStyle(this._el.nativeElement, 'display', value);\n\n      return;\n    }\n\n    this._display = value;\n\n    if (value === 'none') {\n      this.hide();\n\n      return;\n    }\n\n    this.show();\n  }\n  /** turn on/off animation */\n  @Input() isAnimated = false;\n  /** A flag indicating visibility of content (shown or hidden) */\n  @Input()\n  set collapse(value: boolean) {\n    this.collapseNewValue = value;\n    if (!this._player || this._isAnimationDone) {\n      this.isExpanded = value;\n      this.toggle();\n    }\n  }\n\n  get collapse(): boolean {\n    return this.isExpanded;\n  }\n\n  private _display = 'block';\n  private _isAnimationDone?: boolean;\n  private _player?: AnimationPlayer;\n  private _stylesLoaded = false;\n\n  private _COLLAPSE_ACTION_NAME = 'collapse';\n  private _EXPAND_ACTION_NAME = 'expand';\n\n  private readonly _factoryCollapseAnimation: AnimationFactory;\n  private readonly _factoryExpandAnimation: AnimationFactory;\n\n  constructor(\n    private _el: ElementRef,\n    private _renderer: Renderer2,\n    _builder: AnimationBuilder\n  ) {\n    this._factoryCollapseAnimation = _builder.build(collapseAnimation);\n    this._factoryExpandAnimation = _builder.build(expandAnimation);\n  }\n\n  ngAfterViewChecked(): void {\n    this._stylesLoaded = true;\n\n    if (!this._player || !this._isAnimationDone) {\n      return;\n    }\n\n    this._player.reset();\n    this._renderer.setStyle(this._el.nativeElement, 'height', '*');\n  }\n\n  /** allows to manually toggle content visibility */\n  toggle(): void {\n    if (this.isExpanded) {\n      this.hide();\n    } else {\n      this.show();\n    }\n  }\n\n  /** allows to manually hide content */\n  hide(): void {\n    this.isCollapsing = true;\n    this.isExpanded = false;\n    this.isCollapsed = true;\n    this.isCollapsing = false;\n\n    this.collapses.emit(this);\n\n    this._isAnimationDone = false;\n\n    this.animationRun(\n      this.isAnimated,\n      this._COLLAPSE_ACTION_NAME\n    )(() => {\n      this._isAnimationDone = true;\n      if (this.collapseNewValue !== this.isCollapsed && this.isAnimated) {\n        this.show();\n\n        return;\n      }\n      this.collapsed.emit(this);\n      this._renderer.setStyle(this._el.nativeElement, 'display', 'none');\n    });\n  }\n  /** allows to manually show collapsed content */\n  show(): void {\n    this._renderer.setStyle(this._el.nativeElement, 'display', this._display);\n\n    this.isCollapsing = true;\n    this.isExpanded = true;\n    this.isCollapsed = false;\n    this.isCollapsing = false;\n\n    this.expands.emit(this);\n\n    this._isAnimationDone = false;\n    this.animationRun(\n      this.isAnimated,\n      this._EXPAND_ACTION_NAME\n    )(() => {\n      this._isAnimationDone = true;\n      if (this.collapseNewValue !== this.isCollapsed && this.isAnimated) {\n        this.hide();\n\n        return;\n      }\n      this.expanded.emit(this);\n      this._renderer.removeStyle(this._el.nativeElement, 'overflow');\n    });\n  }\n\n  animationRun(isAnimated: boolean, action: string) {\n    if (!isAnimated || !this._stylesLoaded) {\n      return (callback: () => void) => callback();\n    }\n\n    this._renderer.setStyle(this._el.nativeElement, 'overflow', 'hidden');\n    this._renderer.addClass(this._el.nativeElement, 'collapse');\n\n    const factoryAnimation =\n      action === this._EXPAND_ACTION_NAME\n        ? this._factoryExpandAnimation\n        : this._factoryCollapseAnimation;\n\n    if (this._player) {\n      this._player.destroy();\n    }\n\n    this._player = factoryAnimation.create(this._el.nativeElement);\n    this._player.play();\n\n    return (callback: () => void) => this._player?.onDone(callback);\n  }\n}\n"]}

package/esm2015/form-entry/directives/historical-value.directive.js

@@ -0,0 +1,67 @@
+import { Directive, HostListener, Input, Output, EventEmitter } from '@angular/core';
+import { HistoricalFieldHelperService } from '../helpers/historical-field-helper-service';
+import * as _ from 'lodash';
+import { NodeBase } from '../form-factory/form-node';
+import * as i0 from "@angular/core";
+import * as i1 from "../helpers/historical-field-helper-service";
+export class HistoricalValueDirective {
+    constructor(historicalFieldHelper) {
+        this.historicalFieldHelper = historicalFieldHelper;
+        this._nodeChange = new EventEmitter();
+    }
+    setValue(e) {
+        if (e.target.name === 'historyValue') {
+            if (this._node &&
+                (!this.compareStrings(this._node.question.renderingType, 'page') ||
+                    !this.compareStrings(this._node.question.renderingType, 'section'))) {
+                this._node.control.setValue(this._node.question.historicalDataValue.value);
+                this._node.question['historicalValue'] = this._node.question.historicalDataValue;
+                e.stopPropagation();
+                this._nodeChange.emit(this._node);
+            }
+        }
+    }
+    set node(node) {
+        if (node) {
+            this._node = node;
+            if (this._node.question.enableHistoricalValue &&
+                !_.isUndefined(this._node.question.historicalDataValue)) {
+                const display = { text: '', _date: '' };
+                if (this._node.question.renderingType === 'select' ||
+                    this._node.question.renderingType === 'multi-select' ||
+                    this._node.question.renderingType === 'single-select') {
+                    display.text = this.historicalFieldHelper.getDisplayTextFromOptions(this._node.question, 'value', 'label');
+                    display._date = this._node.question.historicalDataValue.valueDate;
+                    this._node.question['historicalDisplay'] = display;
+                }
+                else if (!_.isUndefined(this._node.question.historicalDataValue)) {
+                    display.text = this._node.question.historicalDataValue.value;
+                    display._date = this._node.question.historicalDataValue.valueDate;
+                    this._node.question['historicalDisplay'] = display;
+                }
+            }
+        }
+    }
+    compareStrings(a, b) {
+        return a === b;
+    }
+}
+HistoricalValueDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HistoricalValueDirective, deps: [{ token: i1.HistoricalFieldHelperService }], target: i0.ɵɵFactoryTarget.Directive });
+HistoricalValueDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: HistoricalValueDirective, selector: "[node]", inputs: { _node: "_node", node: "node" }, outputs: { _nodeChange: "_nodeChange" }, host: { listeners: { "click": "setValue($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HistoricalValueDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: `[node]`
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HistoricalFieldHelperService }]; }, propDecorators: { _node: [{
+                type: Input
+            }], _nodeChange: [{
+                type: Output
+            }], setValue: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], node: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/form-entry/error-renderer/error-renderer.component.js

@@ -0,0 +1,56 @@
+import { Component, Input } from '@angular/core';
+import * as _ from 'lodash';
+import { Form } from '../form-factory/form';
+import { ValidationFactory } from '../form-factory/validation.factory';
+import { FormErrorsService } from '../services/form-errors.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../form-factory/validation.factory";
+import * as i2 from "../services/form-errors.service";
+import * as i3 from "@angular/common";
+export class ErrorRendererComponent {
+    constructor(validationFactory, formErrorsService) {
+        this.validationFactory = validationFactory;
+        this.formErrorsService = formErrorsService;
+    }
+    showErrors() {
+        return !this.form.valid && this.form.showErrors;
+    }
+    get errorNodes() {
+        const invalidControls = this.form.markInvalidControls(this.form.rootNode, []);
+        return invalidControls;
+    }
+    getControlError(node) {
+        const errors = node.control.errors;
+        if (errors) {
+            return this.validationFactory.errors(errors, node.question);
+        }
+        return [];
+    }
+    announceErrorField(errorNode) {
+        const nodes = this.form.searchNodeByQuestionId(errorNode.path.substring(0, errorNode.path.indexOf('.')));
+        _.forEach(nodes, (node) => {
+            if (node.question.renderingType === 'page') {
+                const pageIndex = this.getPageIndex(node);
+                this.formErrorsService.announceErrorField(pageIndex + ',' + errorNode.question.key);
+            }
+        });
+    }
+    getPageIndex(node) {
+        const questionGroup = this.form.rootNode
+            .question;
+        return questionGroup.questions.indexOf(node.question);
+    }
+}
+ErrorRendererComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ErrorRendererComponent, deps: [{ token: i1.ValidationFactory }, { token: i2.FormErrorsService }], target: i0.ɵɵFactoryTarget.Component });
+ErrorRendererComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: ErrorRendererComponent, selector: "ofe-error-renderer", inputs: { form: "form" }, ngImport: i0, template: "<div *ngIf=\"showErrors()\" class=\"container\">\n  <div\n    data-notification\n    *ngFor=\"let errorNode of errorNodes\"\n    class=\"cds--inline-notification cds--inline-notification--error cds--inline-notification--low-contrast pointer\"\n    role=\"alert\"\n    (click)=\"announceErrorField(errorNode)\"\n  >\n    <div class=\"cds--inline-notification__details\">\n      <div class=\"cds--inline-notification__text-wrapper\">\n        <p class=\"cds--inline-notification__title\">\n          {{ errorNode.question.label }}\n        </p>\n        <p class=\"cds--inline-notification__subtitle\">\n          {{ getControlError(errorNode) }}\n        </p>\n      </div>\n    </div>\n    <button\n      tabindex=\"0\"\n      class=\"cds--inline-notification__action-button cds--btn cds--btn--sm cds--btn--ghost\"\n      type=\"button\"\n    >\n      Fix\n    </button>\n    <svg\n      focusable=\"false\"\n      preserveAspectRatio=\"xMidYMid meet\"\n      style=\"will-change: transform\"\n      xmlns=\"http://www.w3.org/2000/svg\"\n      class=\"cds--inline-notification__icon\"\n      width=\"20\"\n      height=\"20\"\n      viewBox=\"0 0 20 20\"\n      aria-hidden=\"true\"\n    >\n      <path\n        d=\"M10,1c-5,0-9,4-9,9s4,9,9,9s9-4,9-9S15,1,10,1z M13.5,14.5l-8-8l1-1l8,8L13.5,14.5z\"\n      ></path>\n      <path\n        d=\"M13.5,14.5l-8-8l1-1l8,8L13.5,14.5z\"\n        data-icon-path=\"inner-path\"\n        opacity=\"0\"\n      ></path>\n    </svg>\n  </div>\n</div>\n", styles: ["ul{list-style:none}.list-group-item{padding:2px 15px;cursor:pointer}ul li:hover{background-color:#fff}h4{margin-top:7px;margin-bottom:7px}.pointer{cursor:pointer}\n"], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ErrorRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ofe-error-renderer',
+                    templateUrl: 'error-renderer.component.html',
+                    styleUrls: ['./error-renderer.component.css']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ValidationFactory }, { type: i2.FormErrorsService }]; }, propDecorators: { form: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/form-entry/expression-runner/expression-runner.js

@@ -0,0 +1,170 @@
+import { Injectable } from '@angular/core';
+import { ArrayNode } from '../form-factory/form-node';
+import { ControlRelationsFactory } from '../form-factory/control-relations.factory';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+export class ExpressionRunner {
+    getRunnable(expression, control, helper, dataDependencies, form) {
+        const runner = this;
+        const runnable = {
+            run: () => {
+                let scope = {};
+                if (control.uuid) {
+                    scope[control.uuid] = control.value;
+                }
+                window['moment'] = moment;
+                // scope.moment = moment;
+                scope['myValue'] = control.value;
+                scope['FORM'] = {};
+                runner.setControlQuestion(control, form, scope);
+                runner.getControlRelationValueString(control, scope);
+                runner.getHelperMethods(helper, scope);
+                runner.getDataDependencies(dataDependencies, scope);
+                if (form) {
+                    // console.error('Form defined', form);
+                    runner.getDataDependencies(form.dataSourcesContainer.dataSources, scope);
+                }
+                let paramList = '';
+                let argList = '';
+                for (let o in scope) {
+                    paramList = paramList === '' ? paramList + o : paramList + ',' + o;
+                    argList =
+                        argList === ''
+                            ? argList + "scope['" + o + "']"
+                            : argList + ",scope['" + o + "']";
+                }
+                // prevent more than one return statements
+                if (expression.indexOf('return') === -1) {
+                    expression = 'return ' + expression;
+                }
+                try {
+                    const afeDynamicFunc = new Function(paramList, expression);
+                    scope[Symbol.iterator] = function* () {
+                        var k;
+                        for (k in this) {
+                            yield this[k];
+                        }
+                    };
+                    if (Object.keys(scope).indexOf('undefined') >= 0) {
+                        console.warn('Missing reference found', expression, scope);
+                        return false;
+                    }
+                    return afeDynamicFunc.call(this, ...scope);
+                }
+                catch (error) {
+                    // if (window['error_count']) {
+                    //     window['error_count'] = window['error_count'] + 1;
+                    // } else {
+                    //     window['error_count'] = 1;
+                    // }
+                    // console.error(window['error_count'] + ' Error running expression:' + expression + '. ',
+                    //     e, control, 'Effective Expression', (funcDeclarationCode + funcCallCode));
+                    // console.error('Error running expression:' + expression + '. ',
+                    //     e, control, 'Effective Expression', (funcDeclarationCode + funcCallCode));
+                    // Uncomment the line above during debugging
+                    // console.error(`Error running expression: ${expression} scope: ${scope} error: ${error}`);
+                    return false;
+                }
+                /* eslint-enable */
+            }
+        };
+        return runnable;
+    }
+    getControlRelationValueString(control, scope) {
+        if (control &&
+            control.controlRelations &&
+            control.controlRelations.relations) {
+            control.controlRelations.relations.forEach((relation) => {
+                if (relation.relatedTo) {
+                    const related = relation.relatedTo;
+                    const relatedAsControl = relation.relatedTo;
+                    if (relatedAsControl && Array.isArray(relatedAsControl.value)) {
+                        scope[related.uuid] = relation.relatedTo.value;
+                    }
+                    else {
+                        scope[related.uuid] =
+                            relation.relatedTo.value && relation.relatedTo.value.value
+                                ? relation.relatedTo.value.value
+                                : relation.relatedTo.value;
+                    }
+                }
+            });
+        }
+        if (control &&
+            control.controlRelations &&
+            control.controlRelations.otherRelations &&
+            control.controlRelations.otherRelations.length > 0) {
+            control.controlRelations.otherRelations.forEach((node) => {
+                if (node instanceof ArrayNode) {
+                    const arrayNode = node;
+                    const uuid = control.uuid;
+                    const controlRelationsFactory = new ControlRelationsFactory();
+                    let relationsForControl = [];
+                    // get all related controls
+                    arrayNode.children.forEach((child) => {
+                        relationsForControl = relationsForControl.concat(controlRelationsFactory.getRelationsForControl(uuid, child));
+                    });
+                    this.setControlArrayValues(control, relationsForControl, scope);
+                }
+            });
+        }
+    }
+    setControlQuestion(control, form, scope) {
+        if (form &&
+            control &&
+            control.controlRelations &&
+            control.controlRelations.relations) {
+            control.controlRelations.relations.forEach((relation) => {
+                var _a, _b;
+                const related = relation.relatedTo;
+                const question = (_b = (_a = form.searchNodeByQuestionId(related.uuid)[0]) === null || _a === void 0 ? void 0 : _a.question) === null || _b === void 0 ? void 0 : _b.extras;
+                scope['FORM'][related.uuid] = question;
+            });
+        }
+    }
+    setControlArrayValues(control, relationsForControl, scope) {
+        const keys = this._getFormControlKeys(relationsForControl);
+        keys.forEach((key) => {
+            const values = this._getValuesForKey(key, relationsForControl);
+            scope[key] = values;
+        });
+    }
+    _getFormControlKeys(array) {
+        const keys = [];
+        array.forEach((control) => {
+            if (keys.indexOf(control.uuid) === -1) {
+                keys.push(control.uuid);
+            }
+        });
+        return keys;
+    }
+    _getValuesForKey(key, array) {
+        const values = [];
+        array.forEach((control) => {
+            if (control.uuid === key) {
+                values.push(control.value);
+            }
+        });
+        return values;
+    }
+    getHelperMethods(obj, scope) {
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                scope[key] = obj[key];
+            }
+        }
+    }
+    getDataDependencies(obj, scope) {
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                scope[key] = obj[key];
+            }
+        }
+    }
+}
+ExpressionRunner.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ExpressionRunner, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ExpressionRunner.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ExpressionRunner });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ExpressionRunner, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"expression-runner.js","sourceRoot":"","sources":["../../../../../projects/ngx-formentry/src/form-entry/expression-runner/expression-runner.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { AbstractControl } from '@angular/forms';\nimport {\n  AfeFormControl,\n  AfeFormArray,\n  AfeFormGroup\n} from '../../abstract-controls-extension/control-extensions';\nimport { ArrayNode } from '../form-factory/form-node';\nimport { ControlRelationsFactory } from '../form-factory/control-relations.factory';\nimport { Form } from '../form-factory/form';\nimport moment from 'moment';\n@Injectable()\nexport class ExpressionRunner {\n  getRunnable(\n    expression: string,\n    control: AfeFormArray | AfeFormGroup | AfeFormControl,\n    helper: any,\n    dataDependencies: any,\n    form?: Form\n  ): Runnable {\n    const runner = this;\n    const runnable: Runnable = {\n      run: () => {\n        let scope: any = {};\n        if (control.uuid) {\n          scope[control.uuid] = control.value;\n        }\n        window['moment'] = moment;\n        // scope.moment = moment;\n        scope['myValue'] = control.value;\n        scope['FORM'] = {};\n        runner.setControlQuestion(control, form, scope);\n        runner.getControlRelationValueString(control, scope);\n        runner.getHelperMethods(helper, scope);\n        runner.getDataDependencies(dataDependencies, scope);\n        if (form) {\n          // console.error('Form defined', form);\n          runner.getDataDependencies(\n            form.dataSourcesContainer.dataSources,\n            scope\n          );\n        }\n\n        let paramList = '';\n        let argList = '';\n        for (let o in scope) {\n          paramList = paramList === '' ? paramList + o : paramList + ',' + o;\n          argList =\n            argList === ''\n              ? argList + \"scope['\" + o + \"']\"\n              : argList + \",scope['\" + o + \"']\";\n        }\n\n        // prevent more than one return statements\n        if (expression.indexOf('return') === -1) {\n          expression = 'return ' + expression;\n        }\n\n        try {\n          const afeDynamicFunc = new Function(paramList, expression);\n          scope[Symbol.iterator] = function* () {\n            var k;\n            for (k in this) {\n              yield this[k];\n            }\n          };\n          if (Object.keys(scope).indexOf('undefined') >= 0) {\n            console.warn('Missing reference found', expression, scope);\n            return false;\n          }\n          return afeDynamicFunc.call(this, ...scope);\n        } catch (error) {\n          // if (window['error_count']) {\n          //     window['error_count'] = window['error_count'] + 1;\n          // } else {\n          //     window['error_count'] = 1;\n          // }\n          // console.error(window['error_count'] + ' Error running expression:' + expression + '. ',\n          //     e, control, 'Effective Expression', (funcDeclarationCode + funcCallCode));\n          // console.error('Error running expression:' + expression + '. ',\n          //     e, control, 'Effective Expression', (funcDeclarationCode + funcCallCode));\n\n          // Uncomment the line above during debugging\n          // console.error(`Error running expression: ${expression} scope: ${scope} error: ${error}`);\n\n          return false;\n        }\n        /* eslint-enable */\n      }\n    };\n    return runnable;\n  }\n\n  private getControlRelationValueString(\n    control: AfeFormArray | AfeFormGroup | AfeFormControl,\n    scope: any\n  ) {\n    if (\n      control &&\n      control.controlRelations &&\n      control.controlRelations.relations\n    ) {\n      control.controlRelations.relations.forEach((relation) => {\n        if (relation.relatedTo) {\n          const related = relation.relatedTo as any;\n          const relatedAsControl = relation.relatedTo as AbstractControl;\n          if (relatedAsControl && Array.isArray(relatedAsControl.value)) {\n            scope[related.uuid] = relation.relatedTo.value;\n          } else {\n            scope[related.uuid] =\n              relation.relatedTo.value && relation.relatedTo.value.value\n                ? relation.relatedTo.value.value\n                : relation.relatedTo.value;\n          }\n        }\n      });\n    }\n\n    if (\n      control &&\n      control.controlRelations &&\n      control.controlRelations.otherRelations &&\n      control.controlRelations.otherRelations.length > 0\n    ) {\n      control.controlRelations.otherRelations.forEach((node) => {\n        if (node instanceof ArrayNode) {\n          const arrayNode: ArrayNode = node as ArrayNode;\n          const uuid = control.uuid;\n\n          const controlRelationsFactory: ControlRelationsFactory = new ControlRelationsFactory();\n          let relationsForControl: Array<AfeFormControl | AfeFormArray> = [];\n          // get all related controls\n          arrayNode.children.forEach((child) => {\n            relationsForControl = relationsForControl.concat(\n              controlRelationsFactory.getRelationsForControl(uuid, child)\n            );\n          });\n\n          this.setControlArrayValues(\n            control as AfeFormControl | AfeFormArray,\n            relationsForControl,\n            scope\n          );\n        }\n      });\n    }\n  }\n\n  private setControlQuestion(\n    control: AfeFormArray | AfeFormGroup | AfeFormControl,\n    form: Form,\n    scope: any\n  ) {\n    if (\n      form &&\n      control &&\n      control.controlRelations &&\n      control.controlRelations.relations\n    ) {\n      control.controlRelations.relations.forEach((relation) => {\n        const related = relation.relatedTo as any;\n        const question = form.searchNodeByQuestionId(related.uuid)[0]?.question\n          ?.extras;\n        scope['FORM'][related.uuid] = question;\n      });\n    }\n  }\n\n  private setControlArrayValues(\n    control: AfeFormControl | AfeFormArray,\n    relationsForControl: Array<AfeFormControl | AfeFormArray>,\n    scope: any\n  ) {\n    const keys: Array<string> = this._getFormControlKeys(relationsForControl);\n\n    keys.forEach((key) => {\n      const values: any = this._getValuesForKey(key, relationsForControl);\n      scope[key] = values;\n    });\n  }\n\n  private _getFormControlKeys(\n    array: Array<AfeFormControl | AfeFormArray>\n  ): Array<string> {\n    const keys: Array<string> = [];\n    array.forEach((control) => {\n      if (keys.indexOf(control.uuid) === -1) {\n        keys.push(control.uuid);\n      }\n    });\n\n    return keys;\n  }\n\n  private _getValuesForKey(\n    key: string,\n    array: Array<AfeFormControl | AfeFormArray>\n  ): any {\n    const values: any = [];\n\n    array.forEach((control) => {\n      if (control.uuid === key) {\n        values.push(control.value);\n      }\n    });\n\n    return values;\n  }\n\n  private getHelperMethods(obj: any, scope?: any) {\n    for (const key in obj) {\n      if (obj.hasOwnProperty(key)) {\n        scope[key] = obj[key];\n      }\n    }\n  }\n\n  private getDataDependencies(obj: any, scope?: any) {\n    for (const key in obj) {\n      if (obj.hasOwnProperty(key)) {\n        scope[key] = obj[key];\n      }\n    }\n  }\n}\n\nexport interface Runnable {\n  run();\n}\n"]}