@magic-xpa/angular 4.800.0-dev480.21 → 4.800.0-dev480.210

package/fesm2015/magic-xpa-angular.js

@@ -1,36 +1,31 @@
 import { isNullOrUndefined, isUndefined } from 'util';
-import { ɵɵdefineInjectable, ɵsetClassMetadata, Injectable, Input, Output, ɵɵdirectiveInject, ViewContainerRef, ComponentFactoryResolver, ɵɵdefineDirective, Directive, ɵɵgetCurrentView, ɵɵelementStart, ɵɵlistener, ɵɵrestoreView, ɵɵnextContext, ɵɵtext, ɵɵelementEnd, ɵɵadvance, ɵɵtextInterpolate1, EventEmitter, Injector, ɵɵdefineComponent, ɵɵviewQuery, ɵɵqueryRefresh, ɵɵloadQuery, ɵɵInheritDefinitionFeature, ɵɵtemplate, ɵɵelement, ɵɵproperty, Component, ViewChild, ElementRef, NgModuleFactoryLoader, ChangeDetectorRef, ɵɵstaticViewQuery, ɵɵgetInheritedFactory, ɵɵinject, ɵɵProvidersFeature, HostListener, Renderer2, Optional, ɵɵdefinePipe, Pipe, ɵɵprojection, ɵɵprojectionDef, ɵɵelementContainer, ɵɵreference, ɵɵresolveWindow, ɵɵtemplateRefExtractor, forwardRef, ɵɵdefineNgModule, ɵɵdefineInjector, ɵɵsetNgModuleScope, NgModule } from '@angular/core';
+import { ɵɵdefineInjectable, ɵsetClassMetadata, Injectable, ɵɵinject, NgModuleFactoryLoader, Injector, ɵɵdirectiveInject, ComponentFactoryResolver, ViewContainerRef, ɵɵdefineComponent, Component, Input, Output, ɵɵdefineDirective, Directive, ɵɵgetCurrentView, ɵɵelementStart, ɵɵlistener, ɵɵrestoreView, ɵɵnextContext, ɵɵtext, ɵɵelementEnd, ɵɵadvance, ɵɵtextInterpolate1, EventEmitter, ɵɵviewQuery, ɵɵqueryRefresh, ɵɵloadQuery, ɵɵInheritDefinitionFeature, ɵɵtemplate, ɵɵelement, ɵɵproperty, ViewChild, ElementRef, ChangeDetectorRef, ɵɵstaticViewQuery, ɵɵgetInheritedFactory, ɵɵProvidersFeature, HostListener, Renderer2, Optional, ɵɵdefinePipe, Pipe, ɵɵprojection, ɵɵprojectionDef, ɵɵelementContainer, ɵɵreference, ɵɵresolveWindow, ɵɵtemplateRefExtractor, forwardRef, ɵɵdefineNgModule, ɵɵdefineInjector, ɵɵsetNgModuleScope, NgModule } from '@angular/core';
 import { NgIf, NgStyle, DatePipe, NgTemplateOutlet, CommonModule, formatDate } from '@angular/common';
 import { ActivatedRoute, Router, RouterModule } from '@angular/router';
 import { FormGroup, FormControl, Validators, NG_VALIDATORS, NG_VALUE_ACCESSOR, CheckboxControlValueAccessor, DefaultValueAccessor, FormsModule, ReactiveFormsModule } from '@angular/forms';
 import { DynamicComponent, DynamicIoDirective, DynamicModule } from 'ng-dynamic-component';
 import { __awaiter, __decorate, __metadata } from 'tslib';
 import { Subject } from 'rxjs';
-import { MagicBridge, getGuiEventObj } from '@magic-xpa/engine';
+import { MagicBridge, getGuiEventObj, CookieService } from '@magic-xpa/engine';
 import { InteractiveCommandType, OverlayType, Styles, HtmlProperties, GuiConstants, CommandType, PIC, GuiEnvironment, Modifiers } from '@magic-xpa/gui';
-import { MagicProperties, StorageAttribute, Logger, BindingLevel, StorageAttributeType, StrUtil, PICInterface } from '@magic-xpa/utils';
+import { MagicProperties, Logger, StrUtil, StorageAttribute, BindingLevel, StorageAttributeType, PICInterface } from '@magic-xpa/utils';
 import { filter, map, debounceTime } from 'rxjs/operators';
-import { NString, StringBuilder, List, RefParam } from '@magic-xpa/mscorelib';
+import { NString, List, StringBuilder, RefParam } from '@magic-xpa/mscorelib';
 import { Title } from '@angular/platform-browser';
 import { fromEvent } from 'rxjs/internal/observable/fromEvent';
 import { HttpClient, HttpClientModule } from '@angular/common/http';
 import { NativeDateAdapter, DateAdapter, MAT_DATE_FORMATS } from '@angular/material/core';
 import { Platform } from '@angular/cdk/platform';
 
-/**
- * @ignore
- */
 class ControlMetadata {
     constructor() {
         this.properties = new Map();
         this.classesMap = new Map();
         this.stylesMap = new Map();
-        // user properties
         this.userProperties = new Map();
         this.customValidators = new Map();
     }
     setClass(key, value) {
-        // for no-control - hold the name of the class to be removed later
         if (this.classesMap.has(key)) {
             this.removedClass = this.classesMap.get(key);
         }
@@ -45,14 +40,9 @@ class ControlMetadata {
         this.stylesMap.set(key, value);
     }
 }
-/**
- * @ignore
- */
 class ControlsMetadata {
     constructor() {
-        //values of control
         this.values = new Map();
-        // dictionary of controls with there properties
         this.ControlsProperties = new Map();
         this.isCreated = false;
         this.isEditing = false;
@@ -66,8 +56,6 @@ class ControlsMetadata {
         return this.ControlsProperties.get(controlId);
     }
     update(obj) {
-        //should we keep the values here ?
-        //this.values = obj.ControlsValues;
         let props = obj.ControlsMetaData;
         for (let controlName in props) {
             if (!this.ControlsProperties.has(controlName))
@@ -96,16 +84,13 @@ class ControlsMetadata {
         return this.values.get(controlName);
     }
 }
-/**
- * @ignore
- */
 class Records {
     constructor() {
         this.data = new Map();
-        this.list = []; //used for sequential access in table
+        this.list = [];
         this.recordsBeforeCurrentView = 0;
         this.isEmptyDataView = false;
-        this.sizeUpdated = false; //used for evaluating the RecordsSizeChange.
+        this.sizeUpdated = false;
     }
     getRow(dvRowId) {
         return this.list[dvRowId + this.recordsBeforeCurrentView];
@@ -129,24 +114,14 @@ class Records {
         }
         return false;
     }
-    /*
-    * for row editing
-    * */
     startRowEditing(guiRowId) {
         if (guiRowId < this.list.length && this.data.has(guiRowId))
             this.data.get(guiRowId).isEditing = true;
     }
-    /*
-    * stop row editing on row Id
-    * */
     stopRowEditing(guiRowId) {
         if (guiRowId < this.list.length && this.data.has(guiRowId))
             this.data.get(guiRowId).isEditing = false;
     }
-    /*
-    * return if row is in editing
-    * Called by the HTML code, so parameter is a string, not a numebr
-    * */
     isRowInRowEditing(guiRowId) {
         if (+guiRowId < this.list.length) {
             if (!this.data.has(+guiRowId) || isNullOrUndefined(this.data.get(+guiRowId)))
@@ -175,7 +150,6 @@ class Records {
     updateSize(len) {
         if (this.list.length != len) {
             if (len < this.list.length) {
-                //remove rows
                 for (let i = len; i < this.list.length; i++) {
                     this.data.delete(i);
                 }
@@ -184,10 +158,6 @@ class Records {
             this.sizeUpdated = true;
         }
     }
-    /**
-     * crears data for the first record
-     * @param template
-     */
     clearFirstTableRecord(template) {
         if (this.list.length >= 1) {
             for (const key in template) {
@@ -218,9 +188,6 @@ class Records {
         return this.guiTopIndex;
     }
 }
-/**
- * @ignore
- */
 var HtmlClasses;
 (function (HtmlClasses) {
     HtmlClasses["Color"] = "color";
@@ -229,16 +196,11 @@ var HtmlClasses;
     HtmlClasses["HintColor"] = "hintcolor";
 })(HtmlClasses || (HtmlClasses = {}));
 
-/**
- * @ignore
- */
 class EngineMagicService {
     constructor() {
         this.magicBridge = MagicBridge;
         this.isStub = false;
-        // true when user is logged in magic
         this.isLoggedIn = false;
-        //TODO - unregister
         this.refreshDom = new Subject();
         this.interactiveCommands = new Subject();
     }
@@ -281,6 +243,9 @@ class EngineMagicService {
     GetControlPictureMask(taskId, controlName) {
         return this.magicBridge.GetControlPictureMask(taskId, controlName);
     }
+    GetFormattedValue(taskId, controlName, value) {
+        return this.magicBridge.GetFormattedValue(taskId, controlName, value);
+    }
     ValidateControlValue(taskId, controlName, value) {
         return this.magicBridge.ValidateControlValue(taskId, controlName, value);
     }
@@ -288,7 +253,6 @@ class EngineMagicService {
         return this.magicBridge.GetFldRanges(taskId, controlName);
     }
     saveData(data) {
-        //this.magicBridge.saveData(data);
     }
     getIsLoggedIn() {
         return this.isLoggedIn;
@@ -303,24 +267,15 @@ class EngineMagicService {
         this.magicBridge.TerminateContextUsingFetchAPI();
     }
 }
-/** @nocollapse */ EngineMagicService.ɵfac = function EngineMagicService_Factory(t) { return new (t || EngineMagicService)(); };
-/** @nocollapse */ EngineMagicService.ɵprov = ɵɵdefineInjectable({ token: EngineMagicService, factory: EngineMagicService.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(EngineMagicService, [{
+EngineMagicService.ɵfac = function EngineMagicService_Factory(t) { return new (t || EngineMagicService)(); };
+EngineMagicService.ɵprov = ɵɵdefineInjectable({ token: EngineMagicService, factory: EngineMagicService.ɵfac });
+(function () { ɵsetClassMetadata(EngineMagicService, [{
         type: Injectable
     }], null, null); })();
 
-/**
- * Manages the list of components in a project, and the project title
- */
 class ComponentListMagicService {
     constructor() {
-        /**
-         * Map of project components
-         */
         this.components = new Map();
-        /**
-         * Map of project dialogs
-         */
         this.dialogs = new Map();
         this.lazyLoadModulesMap = null;
     }
@@ -334,11 +289,6 @@ class ComponentListMagicService {
             data = this.components.get(name);
         return data;
     }
-    /**
-     * Return a component according to name
-     * @param name Name of requested component
-     * @returns The requested component
-     */
     getComponent(name, mustHaveData = true) {
         let data = this.getData(name, mustHaveData);
         return data ? data.component : null;
@@ -349,29 +299,16 @@ class ComponentListMagicService {
             this.components.set(key, data);
         }
     }
-    /**
-    * Return a component according to name
-    * @param name Name of requested component
-    * @returns The requested component
-    */
     getModuleRef(name) {
         let data = this.getData(name, false);
         return data ? data.moduleRef : null;
         ;
     }
-    /**
-     * Return the lazy load module details of the specified component
-     * @param name: Name of requested component
-     * @returns: lazy load module details
-     */
     getLazyLoadModuleData(name) {
         return (this.lazyLoadModulesMap != null && this.lazyLoadModulesMap.hasOwnProperty(name)) ? this.lazyLoadModulesMap[name] : null;
     }
 }
 
-/**
- * @ignore
- */
 class StylesMapManager {
     static magicValueGetStyle(styleName, magicValue) {
         let style = "";
@@ -398,12 +335,326 @@ StylesMapManager.MagicPropertyToHtmlAttributeMap = new Map([
     [MagicProperties.Wallpaper, "background-image"]
 ]);
 
-/**
- * @ignore
- */
+class CommandsCollectorMagicService {
+    constructor(magic) {
+        this.magic = magic;
+        this.count = 0;
+        this.commands = new List();
+        this.subscription = null;
+    }
+    startCollecting() {
+        this.count++;
+        Logger.Instance.WriteDevToLog("CommandsCollectorMagicService.startCollecting() --- " + this.count);
+        if (this.subscription === null) {
+            this.subscription = this.magic.refreshDom
+                .subscribe(command => {
+                this.commands.push(command);
+            });
+        }
+    }
+    stopCollecting() {
+        this.count--;
+        Logger.Instance.WriteDevToLog("CommandsCollectorMagicService.stopCollecting() --- " + this.count);
+        if (this.count === 0) {
+            this.subscription.unsubscribe();
+            this.subscription = null;
+        }
+    }
+    GetCommands(taskId) {
+        const commands = this.commands.filter((command) => command.TaskTag === taskId);
+        commands.forEach(command => { this.commands.Remove(command); });
+        return commands;
+    }
+}
+CommandsCollectorMagicService.ɵfac = function CommandsCollectorMagicService_Factory(t) { return new (t || CommandsCollectorMagicService)(ɵɵinject(EngineMagicService)); };
+CommandsCollectorMagicService.ɵprov = ɵɵdefineInjectable({ token: CommandsCollectorMagicService, factory: CommandsCollectorMagicService.ɵfac });
+(function () { ɵsetClassMetadata(CommandsCollectorMagicService, [{
+        type: Injectable
+    }], function () { return [{ type: EngineMagicService }]; }, null); })();
+
+class RouteCommand {
+}
+class RouterCommandsMagicService {
+    constructor() {
+        this.pendingRouteCommands = [];
+    }
+    AddRouteCommand(routeCommand) {
+        this.pendingRouteCommands.push(routeCommand);
+    }
+    ExecuteNextCommand() {
+        let pendingRouteCommand = this.pendingRouteCommands.shift();
+        if (!isNullOrUndefined(pendingRouteCommand)) {
+            pendingRouteCommand.callerMgSubformServiceRef.ExecuteRouteCommand(pendingRouteCommand);
+        }
+    }
+}
+RouterCommandsMagicService.ɵfac = function RouterCommandsMagicService_Factory(t) { return new (t || RouterCommandsMagicService)(); };
+RouterCommandsMagicService.ɵprov = ɵɵdefineInjectable({ token: RouterCommandsMagicService, factory: RouterCommandsMagicService.ɵfac });
+(function () { ɵsetClassMetadata(RouterCommandsMagicService, [{
+        type: Injectable
+    }], null, null); })();
+
+class SubformMagicService {
+    constructor(task, activatedRoute, componentList, pendingCommandsCollector, router, routerCommandsMagicService, componentListMagicService, loader, injector) {
+        this.task = task;
+        this.activatedRoute = activatedRoute;
+        this.componentList = componentList;
+        this.pendingCommandsCollector = pendingCommandsCollector;
+        this.router = router;
+        this.routerCommandsMagicService = routerCommandsMagicService;
+        this.componentListMagicService = componentListMagicService;
+        this.loader = loader;
+        this.injector = injector;
+        this.subformsDict = {};
+        this.routesDict = {};
+        this.currentRouteDefinition = null;
+    }
+    mgGetComp(subformName) {
+        if (subformName in this.subformsDict) {
+            let formName = this.subformsDict[subformName].formName;
+            if (formName)
+                return this.componentList.getComponent(formName);
+        }
+        return null;
+    }
+    mgGetParameters(subformName) {
+        if (subformName in this.subformsDict) {
+            return this.subformsDict[subformName].parameters;
+        }
+        else
+            return "";
+    }
+    deleteSubformComp(subformControlName, formName) {
+        if (Object.keys(this.subformsDict).indexOf(subformControlName) >= 0) {
+            if (this.subformsDict[subformControlName].formName === formName) {
+                this.subformsDict[subformControlName] = {};
+                this.task.refreshView();
+            }
+        }
+    }
+    addSubformComp(subformControlName, formName, taskId, taskDescription, routerPath, params, inDefaultOutlet) {
+        this.pendingCommandsCollector.startCollecting();
+        let refreshNeeded = false;
+        if (isNullOrUndefined(routerPath)) {
+            if (Object.keys(this.subformsDict).indexOf(subformControlName) >= 0) {
+                if (this.subformsDict[subformControlName].formName === formName) {
+                    this.subformsDict[subformControlName] = {};
+                    this.task.refreshView();
+                }
+            }
+            let moduleRef = this.componentListMagicService.getModuleRef(formName);
+            if (moduleRef == null) {
+                let lazyLoadModule = this.componentListMagicService.getLazyLoadModuleData(formName);
+                if (lazyLoadModule != null) {
+                    this.loader
+                        .load(lazyLoadModule.modulePath + "#" + lazyLoadModule.moduleName)
+                        .then((moduleFactory) => {
+                        moduleRef = moduleFactory.create(this.injector);
+                        this.subformsDict[subformControlName] = {
+                            formName,
+                            parameters: { taskIdParam: taskId, taskDescription: taskDescription }
+                        };
+                        this.task.refreshView();
+                    });
+                }
+            }
+            else {
+                this.subformsDict[subformControlName] = {
+                    formName,
+                    parameters: { taskIdParam: taskId, taskDescription: taskDescription }
+                };
+                refreshNeeded = true;
+            }
+        }
+        else {
+            if (inDefaultOutlet)
+                subformControlName = "primary";
+            let routeParams = new List();
+            routeParams.push(routerPath);
+            if (params !== null) {
+                routeParams = routeParams.concat(params);
+            }
+            let routeCommand = {
+                callerMgSubformServiceRef: this,
+                routerOutletName: subformControlName,
+                formName: formName,
+                parameters: { taskIdParam: taskId, taskDescription: taskDescription },
+                routeParams: routeParams
+            };
+            if (SubformMagicService.currentCallerMgSubformServiceRef === null)
+                this.ExecuteRouteCommand(routeCommand);
+            else
+                this.routerCommandsMagicService.AddRouteCommand(routeCommand);
+        }
+        if (refreshNeeded)
+            this.task.refreshView();
+    }
+    ExecuteRouteCommand(routeCommand) {
+        let reusingComponent = false;
+        let currentSubformMagicService = routeCommand.callerMgSubformServiceRef;
+        let relativeRoute = SubformMagicService.getRelativeRoute(currentSubformMagicService.activatedRoute);
+        if (currentSubformMagicService.routesDict[routeCommand.routerOutletName] === routeCommand.routeParams[0]) {
+            currentSubformMagicService.router.navigate([{ outlets: { [routeCommand.routerOutletName]: null } }], { relativeTo: relativeRoute })
+                .then((result) => {
+                SubformMagicService.currentCallerMgSubformServiceRef = currentSubformMagicService;
+                currentSubformMagicService.currentRouteDefinition = {
+                    formName: routeCommand.formName,
+                    parameters: routeCommand.parameters
+                };
+                currentSubformMagicService.PerformRouterNavigate(routeCommand.routerOutletName, routeCommand.routeParams);
+            });
+        }
+        else {
+            SubformMagicService.currentCallerMgSubformServiceRef = currentSubformMagicService;
+            currentSubformMagicService.currentRouteDefinition = {
+                formName: routeCommand.formName,
+                parameters: routeCommand.parameters
+            };
+            if (SubformMagicService.routerContainers.length > 0) {
+                let routeContainer = SubformMagicService.routerContainers[0];
+                SubformMagicService.routerContainers.shift();
+                routeContainer.initializeComponent();
+            }
+            else {
+                currentSubformMagicService.PerformRouterNavigate(routeCommand.routerOutletName, routeCommand.routeParams);
+            }
+        }
+    }
+    PerformRouterNavigate(routerOutletName, routeParams) {
+        let relativeRoute = SubformMagicService.getRelativeRoute(this.activatedRoute);
+        this.router.navigate([{ outlets: { [routerOutletName]: routeParams } }], { relativeTo: relativeRoute })
+            .then((result) => {
+            if (result !== null && !result) {
+                let subformMagicService = SubformMagicService.currentCallerMgSubformServiceRef;
+                subformMagicService.currentRouteDefinition = null;
+                SubformMagicService.currentCallerMgSubformServiceRef = null;
+                subformMagicService.pendingCommandsCollector.stopCollecting();
+                subformMagicService.routerCommandsMagicService.ExecuteNextCommand();
+            }
+        });
+    }
+    init() {
+        const pendingCommands = this.pendingCommandsCollector.GetCommands(this.task.taskId);
+        if (pendingCommands.length > 0) {
+            pendingCommands.forEach(command => { this.task.executeCommand(command); });
+            this.task.refreshView();
+        }
+        this.pendingCommandsCollector.stopCollecting();
+    }
+    refreshView() {
+        this.task.refreshView();
+    }
+    static getRelativeRoute(sendActivatedRoute) {
+        let currentActiveRoute = sendActivatedRoute;
+        if (currentActiveRoute.snapshot.routeConfig !== null && currentActiveRoute.snapshot.routeConfig.path === '') {
+            currentActiveRoute = currentActiveRoute.parent;
+            if (!currentActiveRoute.snapshot.routeConfig.loadChildren)
+                console.log("getRelativeRoute(): both path and currentActiveRoute.snapshot.routeConfig.loadChildren are empty.");
+        }
+        return currentActiveRoute;
+    }
+}
+SubformMagicService.currentCallerMgSubformServiceRef = null;
+SubformMagicService.routerContainers = new Array();
+SubformMagicService.ɵfac = function SubformMagicService_Factory(t) { return new (t || SubformMagicService)(ɵɵinject(TaskMagicService), ɵɵinject(ActivatedRoute), ɵɵinject(ComponentListMagicService), ɵɵinject(CommandsCollectorMagicService), ɵɵinject(Router), ɵɵinject(RouterCommandsMagicService), ɵɵinject(ComponentListMagicService), ɵɵinject(NgModuleFactoryLoader), ɵɵinject(Injector)); };
+SubformMagicService.ɵprov = ɵɵdefineInjectable({ token: SubformMagicService, factory: SubformMagicService.ɵfac });
+(function () { ɵsetClassMetadata(SubformMagicService, [{
+        type: Injectable
+    }], function () { return [{ type: TaskMagicService }, { type: ActivatedRoute }, { type: ComponentListMagicService }, { type: CommandsCollectorMagicService }, { type: Router }, { type: RouterCommandsMagicService }, { type: ComponentListMagicService }, { type: NgModuleFactoryLoader }, { type: Injector }]; }, null); })();
+
+class RouterContainerMagicComponent {
+    constructor(activatedRoute, router, magic, containerTaskService, componentFactoryResolver, viewContainerRef, componentList, pendingCommandsCollector, routerCommandsMagicService) {
+        this.activatedRoute = activatedRoute;
+        this.router = router;
+        this.magic = magic;
+        this.containerTaskService = containerTaskService;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.viewContainerRef = viewContainerRef;
+        this.componentList = componentList;
+        this.pendingCommandsCollector = pendingCommandsCollector;
+        this.routerCommandsMagicService = routerCommandsMagicService;
+        this.componentRef = null;
+        this.parentMgSubformService = null;
+    }
+    static get LastRoute() {
+        return RouterContainerMagicComponent.lastRoute;
+    }
+    ngOnInit() {
+        let outletname = this.activatedRoute.outlet;
+        let subformMagicService = SubformMagicService.currentCallerMgSubformServiceRef;
+        let currentActiveRoute = SubformMagicService.getRelativeRoute(this.activatedRoute);
+        RouterContainerMagicComponent.lastRoute = this.router.url;
+        if (subformMagicService == null || subformMagicService.currentRouteDefinition === null) {
+            this.insertRouteEvent(currentActiveRoute);
+            SubformMagicService.routerContainers.push(this);
+        }
+        else {
+            this.initializeComponent();
+        }
+    }
+    insertRouteEvent(currentActiveRoute) {
+        let guiEvent = getGuiEventObj('RouterNavigate', null, 0);
+        guiEvent.RouterPath = currentActiveRoute.snapshot.routeConfig.path;
+        if (currentActiveRoute.snapshot.outlet !== 'primary')
+            guiEvent.RouterOutletName = currentActiveRoute.snapshot.outlet;
+        let calcRouterPath = currentActiveRoute.routeConfig.path;
+        if (calcRouterPath.length > 0) {
+            let routerPath = calcRouterPath;
+            let tokens = StrUtil.tokenize(routerPath, "/:");
+            guiEvent.RouterPath = tokens[0];
+            guiEvent.RouterParams = new List();
+            for (let i = 1; i < tokens.length; i++) {
+                guiEvent.RouterParams.push(this.activatedRoute.snapshot.params[tokens[i]]);
+            }
+        }
+        this.containerTaskService.insertEvent(guiEvent);
+    }
+    initializeComponent() {
+        let subformMagicService = SubformMagicService.currentCallerMgSubformServiceRef;
+        if (subformMagicService.currentRouteDefinition !== null) {
+            let comp = this.componentList.getComponent(subformMagicService.currentRouteDefinition.formName);
+            const componentFactory = this.componentFactoryResolver.resolveComponentFactory(comp);
+            this.componentRef = this.viewContainerRef.createComponent(componentFactory);
+            Object.assign(this.componentRef.instance, subformMagicService.currentRouteDefinition.parameters);
+            let myActiveRoute = SubformMagicService.getRelativeRoute(this.activatedRoute);
+            let routeParams = StrUtil.tokenize(myActiveRoute.snapshot.routeConfig.path, "/:");
+            subformMagicService.routesDict[myActiveRoute.snapshot.outlet] = routeParams[0];
+            this.parentMgSubformService = subformMagicService;
+            subformMagicService.currentRouteDefinition = null;
+            SubformMagicService.currentCallerMgSubformServiceRef = null;
+            let ignoreParamChange = true;
+            myActiveRoute.paramMap.subscribe(params => {
+                if (!ignoreParamChange)
+                    this.insertRouteEvent(myActiveRoute);
+                ignoreParamChange = false;
+            });
+            this.parentMgSubformService.refreshView();
+            this.routerCommandsMagicService.ExecuteNextCommand();
+        }
+    }
+    ngOnDestroy() {
+        if (this.componentRef != null) {
+            this.componentRef.instance.task.close();
+            let currentActiveRoute = SubformMagicService.getRelativeRoute(this.activatedRoute);
+            this.parentMgSubformService.routesDict[currentActiveRoute.outlet] = "";
+            RouterContainerMagicComponent.lastRoute = this.router.url;
+        }
+    }
+}
+RouterContainerMagicComponent.lastRoute = "/";
+RouterContainerMagicComponent.ɵfac = function RouterContainerMagicComponent_Factory(t) { return new (t || RouterContainerMagicComponent)(ɵɵdirectiveInject(ActivatedRoute), ɵɵdirectiveInject(Router), ɵɵdirectiveInject(EngineMagicService), ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ComponentFactoryResolver), ɵɵdirectiveInject(ViewContainerRef), ɵɵdirectiveInject(ComponentListMagicService), ɵɵdirectiveInject(CommandsCollectorMagicService), ɵɵdirectiveInject(RouterCommandsMagicService)); };
+RouterContainerMagicComponent.ɵcmp = ɵɵdefineComponent({ type: RouterContainerMagicComponent, selectors: [["magic-route-outlet"]], decls: 0, vars: 0, template: function RouterContainerMagicComponent_Template(rf, ctx) { }, encapsulation: 2 });
+(function () { ɵsetClassMetadata(RouterContainerMagicComponent, [{
+        type: Component,
+        args: [{
+                selector: 'magic-route-outlet',
+                template: `
+  `
+            }]
+    }], function () { return [{ type: ActivatedRoute }, { type: Router }, { type: EngineMagicService }, { type: TaskMagicService }, { type: ComponentFactoryResolver }, { type: ViewContainerRef }, { type: ComponentListMagicService }, { type: CommandsCollectorMagicService }, { type: RouterCommandsMagicService }]; }, null); })();
+
 class GuiInteractiveExecutor {
     Run() {
-        // Sets the currentContextID
         try {
             switch (this.command._commandType) {
                 case InteractiveCommandType.GET_VALUE:
@@ -430,11 +681,13 @@ class GuiInteractiveExecutor {
                 case InteractiveCommandType.REFRESH_PAGE:
                     this.OnRefreshPage();
                     break;
+                case InteractiveCommandType.GET_LAST_ROUTE:
+                    this.OnGetLastRoute();
+                    break;
             }
         }
         catch (ex) {
             throw ex;
-            //want to see all the exceptions for now
         }
     }
     static executeInteractiveCommand(task, guiIntactiveCommand, overlayService) {
@@ -490,6 +743,9 @@ class GuiInteractiveExecutor {
         else
             this.command._boolVal = this.task.Records.list[guiRowIndex].isEditing;
     }
+    OnGetLastRoute() {
+        this.command.resultString = RouterContainerMagicComponent.LastRoute;
+    }
 }
 
 let BaseMagicOverlayContainer = class BaseMagicOverlayContainer {
@@ -511,21 +767,17 @@ BaseMagicOverlayContainer = __decorate([
     Output()
 ], BaseMagicOverlayContainer);
 
-/**
- * Directive for setting  ViewContainerRef on element
- */
 class MagicViewContainerRef {
     constructor(vcRef, resolver) {
         this.vcRef = vcRef;
         this.resolver = resolver;
-        // For angular 10 -  find the component from the views
         let comp = (this.vcRef._hostView).find(v => v != null && !isNullOrUndefined(v.setViewContainerRef));
         comp.setViewContainerRef(vcRef);
     }
 }
-/** @nocollapse */ MagicViewContainerRef.ɵfac = function MagicViewContainerRef_Factory(t) { return new (t || MagicViewContainerRef)(ɵɵdirectiveInject(ViewContainerRef), ɵɵdirectiveInject(ComponentFactoryResolver)); };
-/** @nocollapse */ MagicViewContainerRef.ɵdir = ɵɵdefineDirective({ type: MagicViewContainerRef, selectors: [["", "magicViewContainerRef", ""]] });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicViewContainerRef, [{
+MagicViewContainerRef.ɵfac = function MagicViewContainerRef_Factory(t) { return new (t || MagicViewContainerRef)(ɵɵdirectiveInject(ViewContainerRef), ɵɵdirectiveInject(ComponentFactoryResolver)); };
+MagicViewContainerRef.ɵdir = ɵɵdefineDirective({ type: MagicViewContainerRef, selectors: [["", "magicViewContainerRef", ""]] });
+(function () { ɵsetClassMetadata(MagicViewContainerRef, [{
         type: Directive,
         args: [{
                 selector: '[magicViewContainerRef]',
@@ -555,36 +807,16 @@ function MagicOverlayContainer_div_5_Template(rf, ctx) { if (rf & 1) {
     ɵɵadvance(2);
     ɵɵtextInterpolate1(" ", ctx_r2.getText(), " ");
 } }
-/**
- * Creates a modal window for Magic modal window components
- */
 class MagicOverlayContainer extends BaseMagicOverlayContainer {
-    /**
-     *
-     * @param injector
-     * @param componentFactoryResolver
-     */
     constructor(injector, componentFactoryResolver) {
         super();
         this.injector = injector;
         this.componentFactoryResolver = componentFactoryResolver;
-        /**
-         *
-         */
         this.ModalComp = null;
-        /**
-         *
-         */
         this.ModalCompParameters = {};
         this.onClose = new EventEmitter();
-        /**
-         *
-         */
         this.componentRef = null;
     }
-    /**
-     *
-     */
     ngOnInit() {
         const factory = this.componentFactoryResolver.resolveComponentFactory(this.ModalComp);
         this.componentRef = this.modalbodyViewContainerRef.createComponent(factory);
@@ -593,10 +825,6 @@ class MagicOverlayContainer extends BaseMagicOverlayContainer {
     setViewContainerRef(vcRef) {
         this.modalbodyViewContainerRef = vcRef;
     }
-    /**
-     * Returns the form name
-     * @returns
-     */
     getText() {
         if (this.componentRef !== null) {
             let comp = this.componentRef.instance;
@@ -605,10 +833,6 @@ class MagicOverlayContainer extends BaseMagicOverlayContainer {
         else
             return "";
     }
-    /**
-     * Returns CSS styles for the window
-     * @returns
-     */
     getStyle() {
         let styles = {};
         if (this.componentRef != undefined) {
@@ -625,10 +849,6 @@ class MagicOverlayContainer extends BaseMagicOverlayContainer {
         }
         return styles;
     }
-    /**
-     * Returns the CSS styles for the client area
-     * @returns
-     */
     getClientAreaStyles() {
         let styles = {};
         if (this.componentRef != undefined) {
@@ -644,33 +864,23 @@ class MagicOverlayContainer extends BaseMagicOverlayContainer {
         }
         return styles;
     }
-    /**
-     * Should the title bar be displayed
-     * @returns
-     */
     getShowTitleBar() {
         if (this.componentRef != undefined) {
             let comp = this.componentRef.instance;
             return comp.ShowTitleBar();
         }
     }
-    /**
-     *
-     */
     OnClose() {
         this.onClose.emit();
     }
-    /**
-     * Handles click in the background window
-     */
     OnBackgroundClick() {
         let comp = this.componentRef.instance;
         if (comp.ShouldCloseOnBackgroundClick())
             this.OnClose();
     }
 }
-/** @nocollapse */ MagicOverlayContainer.ɵfac = function MagicOverlayContainer_Factory(t) { return new (t || MagicOverlayContainer)(ɵɵdirectiveInject(Injector), ɵɵdirectiveInject(ComponentFactoryResolver)); };
-/** @nocollapse */ MagicOverlayContainer.ɵcmp = ɵɵdefineComponent({ type: MagicOverlayContainer, selectors: [["app-magic-overlay-container"]], viewQuery: function MagicOverlayContainer_Query(rf, ctx) { if (rf & 1) {
+MagicOverlayContainer.ɵfac = function MagicOverlayContainer_Factory(t) { return new (t || MagicOverlayContainer)(ɵɵdirectiveInject(Injector), ɵɵdirectiveInject(ComponentFactoryResolver)); };
+MagicOverlayContainer.ɵcmp = ɵɵdefineComponent({ type: MagicOverlayContainer, selectors: [["app-magic-overlay-container"]], viewQuery: function MagicOverlayContainer_Query(rf, ctx) { if (rf & 1) {
         ɵɵviewQuery(_c0, true);
         ɵɵviewQuery(_c1, true);
     } if (rf & 2) {
@@ -700,7 +910,7 @@ class MagicOverlayContainer extends BaseMagicOverlayContainer {
         ɵɵadvance(1);
         ɵɵproperty("ngStyle", ctx.getClientAreaStyles());
     } }, directives: [NgIf, NgStyle, MagicViewContainerRef], styles: [".modal-foreground[_ngcontent-%COMP%]{background-color:#fff}.modal-background[_ngcontent-%COMP%], .modal-foreground[_ngcontent-%COMP%]{bottom:0;left:0;position:fixed;right:0;top:0}.modal-background[_ngcontent-%COMP%]{background-color:#000;opacity:.75}.modal-header[_ngcontent-%COMP%]{background-color:beige;border-bottom:2px solid red}"] });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicOverlayContainer, [{
+(function () { ɵsetClassMetadata(MagicOverlayContainer, [{
         type: Component,
         args: [{
                 selector: 'app-magic-overlay-container',
@@ -737,44 +947,28 @@ class MagicOverlayContainer extends BaseMagicOverlayContainer {
             type: Output
         }] }); })();
 
-/**
- * Service managing overlay windows
- * This is Magic's default provider
- */
 class OverlayContainerMagicProvider {
     getComponent() {
         return MagicOverlayContainer;
     }
 }
-/** @nocollapse */ OverlayContainerMagicProvider.ɵfac = function OverlayContainerMagicProvider_Factory(t) { return new (t || OverlayContainerMagicProvider)(); };
-/** @nocollapse */ OverlayContainerMagicProvider.ɵprov = ɵɵdefineInjectable({ token: OverlayContainerMagicProvider, factory: OverlayContainerMagicProvider.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(OverlayContainerMagicProvider, [{
+OverlayContainerMagicProvider.ɵfac = function OverlayContainerMagicProvider_Factory(t) { return new (t || OverlayContainerMagicProvider)(); };
+OverlayContainerMagicProvider.ɵprov = ɵɵdefineInjectable({ token: OverlayContainerMagicProvider, factory: OverlayContainerMagicProvider.ɵfac });
+(function () { ɵsetClassMetadata(OverlayContainerMagicProvider, [{
         type: Injectable
     }], null, null); })();
 
-/**
- * This is a base class for the magic confirm components
- */
 class BaseMagicConfirmComponent {
     constructor() {
-        /**
-         * onClose Event - to be raised when the component is closed
-         * should pass true when OK is pressed and false when cancel is pressed
-         */
         this.onClose = new EventEmitter();
     }
-    /**
-     * raises close Event
-     * @param result true when OK is pressed and false when cancel is pressed
-     *
-     */
     OnClose(result) {
         this.onClose.emit(result);
     }
 }
-/** @nocollapse */ BaseMagicConfirmComponent.ɵfac = function BaseMagicConfirmComponent_Factory(t) { return new (t || BaseMagicConfirmComponent)(); };
-/** @nocollapse */ BaseMagicConfirmComponent.ɵcmp = ɵɵdefineComponent({ type: BaseMagicConfirmComponent, selectors: [["mg-base-alert"]], inputs: { title: "title", message: "message" }, outputs: { onClose: "onClose" }, decls: 0, vars: 0, template: function BaseMagicConfirmComponent_Template(rf, ctx) { }, styles: [""] });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(BaseMagicConfirmComponent, [{
+BaseMagicConfirmComponent.ɵfac = function BaseMagicConfirmComponent_Factory(t) { return new (t || BaseMagicConfirmComponent)(); };
+BaseMagicConfirmComponent.ɵcmp = ɵɵdefineComponent({ type: BaseMagicConfirmComponent, selectors: [["mg-base-alert"]], inputs: { title: "title", message: "message" }, outputs: { onClose: "onClose" }, decls: 0, vars: 0, template: function BaseMagicConfirmComponent_Template(rf, ctx) { }, styles: [""] });
+(function () { ɵsetClassMetadata(BaseMagicConfirmComponent, [{
         type: Component,
         args: [{
                 selector: 'mg-base-alert',
@@ -789,27 +983,17 @@ class BaseMagicConfirmComponent {
             type: Output
         }] }); })();
 
-/**
- * This is a base class for the magic alert components
- */
 class BaseMagicAlertComponent {
     constructor() {
-        /**
-         * onClose Event - to be raised when the component is closed
-      
-         */
         this.onClose = new EventEmitter();
     }
-    /**
-     * close magic alert
-     */
     OnClose() {
         this.onClose.emit();
     }
 }
-/** @nocollapse */ BaseMagicAlertComponent.ɵfac = function BaseMagicAlertComponent_Factory(t) { return new (t || BaseMagicAlertComponent)(); };
-/** @nocollapse */ BaseMagicAlertComponent.ɵcmp = ɵɵdefineComponent({ type: BaseMagicAlertComponent, selectors: [["mg-base-alert"]], inputs: { title: "title", message: "message" }, outputs: { onClose: "onClose" }, decls: 0, vars: 0, template: function BaseMagicAlertComponent_Template(rf, ctx) { }, styles: [""] });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(BaseMagicAlertComponent, [{
+BaseMagicAlertComponent.ɵfac = function BaseMagicAlertComponent_Factory(t) { return new (t || BaseMagicAlertComponent)(); };
+BaseMagicAlertComponent.ɵcmp = ɵɵdefineComponent({ type: BaseMagicAlertComponent, selectors: [["mg-base-alert"]], inputs: { title: "title", message: "message" }, outputs: { onClose: "onClose" }, decls: 0, vars: 0, template: function BaseMagicAlertComponent_Template(rf, ctx) { }, styles: [""] });
+(function () { ɵsetClassMetadata(BaseMagicAlertComponent, [{
         type: Component,
         args: [{
                 selector: 'mg-base-alert',
@@ -824,9 +1008,6 @@ class BaseMagicAlertComponent {
             type: Output
         }] }); })();
 
-/**
- * Directive for setting focus on element
- */
 class MagicFocusDirective {
     constructor(hostElement) {
         this.hostElement = hostElement;
@@ -835,9 +1016,9 @@ class MagicFocusDirective {
         this.hostElement.nativeElement.focus();
     }
 }
-/** @nocollapse */ MagicFocusDirective.ɵfac = function MagicFocusDirective_Factory(t) { return new (t || MagicFocusDirective)(ɵɵdirectiveInject(ElementRef)); };
-/** @nocollapse */ MagicFocusDirective.ɵdir = ɵɵdefineDirective({ type: MagicFocusDirective, selectors: [["", "magicFocus", ""]] });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicFocusDirective, [{
+MagicFocusDirective.ɵfac = function MagicFocusDirective_Factory(t) { return new (t || MagicFocusDirective)(ɵɵdirectiveInject(ElementRef)); };
+MagicFocusDirective.ɵdir = ɵɵdefineDirective({ type: MagicFocusDirective, selectors: [["", "magicFocus", ""]] });
+(function () { ɵsetClassMetadata(MagicFocusDirective, [{
         type: Directive,
         args: [{
                 selector: '[magicFocus]'
@@ -846,29 +1027,16 @@ class MagicFocusDirective {
 
 const _c0$1 = ["overlayContainerWrapper"];
 class MagicOverlayContainerWrapper {
-    /**
-     *
-     * @param componentFactoryResolver
-     */
     constructor(componentListMagicService, loader, injector, componentFactoryResolver, changeDetectorRef) {
         this.componentListMagicService = componentListMagicService;
         this.loader = loader;
         this.injector = injector;
         this.componentFactoryResolver = componentFactoryResolver;
         this.changeDetectorRef = changeDetectorRef;
-        /**
-         *
-         */
         this.Component = null;
-        /**
-         *
-         */
         this.Parameters = {};
         this.onClose = new EventEmitter();
     }
-    /**
-     *
-     */
     ngOnInit() {
         let moduleRef = this.componentListMagicService.getModuleRef(this.Parameters.MagicFormName);
         if (moduleRef == null) {
@@ -918,17 +1086,13 @@ class MagicOverlayContainerWrapper {
         this.changeDetectorRef.detectChanges();
     }
 }
-/**
- * @ignore
- * contais data of allowed base components to use
- */
 MagicOverlayContainerWrapper.allowedBaseComps = new Map([
     [OverlayType.Overlay, { comp: BaseMagicOverlayContainer, error: 'BaseMagicOverlayContainer . Overlay ' }],
     [OverlayType.Alert, { comp: BaseMagicAlertComponent, error: 'BaseMagicAlertComponent. Alert ' }],
     [OverlayType.ConfirmationBox, { comp: BaseMagicConfirmComponent, error: 'BaseMagicConfirmComponent. Confirmation ' }]
 ]);
-/** @nocollapse */ MagicOverlayContainerWrapper.ɵfac = function MagicOverlayContainerWrapper_Factory(t) { return new (t || MagicOverlayContainerWrapper)(ɵɵdirectiveInject(ComponentListMagicService), ɵɵdirectiveInject(NgModuleFactoryLoader), ɵɵdirectiveInject(Injector), ɵɵdirectiveInject(ComponentFactoryResolver), ɵɵdirectiveInject(ChangeDetectorRef)); };
-/** @nocollapse */ MagicOverlayContainerWrapper.ɵcmp = ɵɵdefineComponent({ type: MagicOverlayContainerWrapper, selectors: [["app-magic-overlay-container-wrapper"]], viewQuery: function MagicOverlayContainerWrapper_Query(rf, ctx) { if (rf & 1) {
+MagicOverlayContainerWrapper.ɵfac = function MagicOverlayContainerWrapper_Factory(t) { return new (t || MagicOverlayContainerWrapper)(ɵɵdirectiveInject(ComponentListMagicService), ɵɵdirectiveInject(NgModuleFactoryLoader), ɵɵdirectiveInject(Injector), ɵɵdirectiveInject(ComponentFactoryResolver), ɵɵdirectiveInject(ChangeDetectorRef)); };
+MagicOverlayContainerWrapper.ɵcmp = ɵɵdefineComponent({ type: MagicOverlayContainerWrapper, selectors: [["app-magic-overlay-container-wrapper"]], viewQuery: function MagicOverlayContainerWrapper_Query(rf, ctx) { if (rf & 1) {
         ɵɵstaticViewQuery(_c0$1, true);
     } if (rf & 2) {
         var _t;
@@ -942,7 +1106,7 @@ MagicOverlayContainerWrapper.allowedBaseComps = new Map([
         ɵɵelement(6, "div", 5);
         ɵɵelementEnd();
     } }, directives: [MagicFocusDirective, MagicViewContainerRef], styles: [".overlay-container-wrapper-background[_ngcontent-%COMP%] {\n      \n      position: fixed;\n      top: 0;\n      z-index: 999;\n      right: 0;\n      bottom: 0;\n      left: 0;\n    }"] });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicOverlayContainerWrapper, [{
+(function () { ɵsetClassMetadata(MagicOverlayContainerWrapper, [{
         type: Component,
         args: [{
                 selector: 'app-magic-overlay-container-wrapper',
@@ -981,13 +1145,10 @@ MagicOverlayContainerWrapper.allowedBaseComps = new Map([
             args: ['overlayContainerWrapper', { static: true }]
         }] }); })();
 
-/***
- * This is sample component for the alert message
- */
 class MagicAlertComponent extends BaseMagicAlertComponent {
 }
-/** @nocollapse */ MagicAlertComponent.ɵfac = function MagicAlertComponent_Factory(t) { return ɵMagicAlertComponent_BaseFactory(t || MagicAlertComponent); };
-/** @nocollapse */ MagicAlertComponent.ɵcmp = ɵɵdefineComponent({ type: MagicAlertComponent, selectors: [["sample-magic-alert-component"]], features: [ɵɵInheritDefinitionFeature], decls: 8, vars: 2, consts: [[1, "mg-message-background"], [3, "click"]], template: function MagicAlertComponent_Template(rf, ctx) { if (rf & 1) {
+MagicAlertComponent.ɵfac = function MagicAlertComponent_Factory(t) { return ɵMagicAlertComponent_BaseFactory(t || MagicAlertComponent); };
+MagicAlertComponent.ɵcmp = ɵɵdefineComponent({ type: MagicAlertComponent, selectors: [["sample-magic-alert-component"]], features: [ɵɵInheritDefinitionFeature], decls: 8, vars: 2, consts: [[1, "mg-message-background"], [3, "click"]], template: function MagicAlertComponent_Template(rf, ctx) { if (rf & 1) {
         ɵɵelementStart(0, "div");
         ɵɵelementStart(1, "div", 0);
         ɵɵelementStart(2, "h2");
@@ -1008,8 +1169,8 @@ class MagicAlertComponent extends BaseMagicAlertComponent {
         ɵɵadvance(2);
         ɵɵtextInterpolate1("", ctx.message, " ");
     } }, styles: [".mg-message-background[_ngcontent-%COMP%] {\n  background-color: #F5F5F5;\n  text-align: center;\n  width: 40%;\n  font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif;\n  padding: 17px;\n  border-radius: 5px;\n  text-align: center;\n  margin-top: 10% ;\n  margin-left: auto;\n  margin-right: auto;\n  border: 1px solid  gray;\n  }\n\n  button[_ngcontent-%COMP%] {\n  background-color: #8CD4F5;\n  color: white;\n  border: none;\n  box-shadow: none;\n  font-size: 17px;\n  font-weight: 500;\n  -webkit-border-radius: 4px;\n  border-radius: 5px;\n  padding: 10px 32px;\n  margin: 26px 5px 0 5px;\n  cursor: pointer;\n  }"] });
-const ɵMagicAlertComponent_BaseFactory = /*@__PURE__*/ ɵɵgetInheritedFactory(MagicAlertComponent);
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicAlertComponent, [{
+const ɵMagicAlertComponent_BaseFactory = ɵɵgetInheritedFactory(MagicAlertComponent);
+(function () { ɵsetClassMetadata(MagicAlertComponent, [{
         type: Component,
         args: [{
                 selector: 'sample-magic-alert-component',
@@ -1053,13 +1214,10 @@ const ɵMagicAlertComponent_BaseFactory = /*@__PURE__*/ ɵɵgetInheritedFactory(
             }]
     }], null, null); })();
 
-/***
- * This is sample component for the confirmation box
- */
 class MagicConfirmationBoxComponent extends BaseMagicConfirmComponent {
 }
-/** @nocollapse */ MagicConfirmationBoxComponent.ɵfac = function MagicConfirmationBoxComponent_Factory(t) { return ɵMagicConfirmationBoxComponent_BaseFactory(t || MagicConfirmationBoxComponent); };
-/** @nocollapse */ MagicConfirmationBoxComponent.ɵcmp = ɵɵdefineComponent({ type: MagicConfirmationBoxComponent, selectors: [["sample-magic-confirmation-box"]], features: [ɵɵInheritDefinitionFeature], decls: 11, vars: 2, consts: [[1, "mg-message-background"], [3, "click"], [1, "cancel", 3, "click"]], template: function MagicConfirmationBoxComponent_Template(rf, ctx) { if (rf & 1) {
+MagicConfirmationBoxComponent.ɵfac = function MagicConfirmationBoxComponent_Factory(t) { return ɵMagicConfirmationBoxComponent_BaseFactory(t || MagicConfirmationBoxComponent); };
+MagicConfirmationBoxComponent.ɵcmp = ɵɵdefineComponent({ type: MagicConfirmationBoxComponent, selectors: [["sample-magic-confirmation-box"]], features: [ɵɵInheritDefinitionFeature], decls: 11, vars: 2, consts: [[1, "mg-message-background"], [3, "click"], [1, "cancel", 3, "click"]], template: function MagicConfirmationBoxComponent_Template(rf, ctx) { if (rf & 1) {
         ɵɵelementStart(0, "div");
         ɵɵelementStart(1, "div", 0);
         ɵɵelementStart(2, "h2");
@@ -1084,8 +1242,8 @@ class MagicConfirmationBoxComponent extends BaseMagicConfirmComponent {
         ɵɵadvance(1);
         ɵɵtextInterpolate1(" ", ctx.message, " ");
     } }, styles: [".mg-message-background[_ngcontent-%COMP%] {\n  background-color: #F5F5F5;\n  text-align: center;\n  width: 40%;\n  font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif;\n  padding: 17px;\n  border-radius: 5px;\n  text-align: center;\n  margin-top: 10% ;\n  margin-left: auto;\n  margin-right: auto;\n  border: 1px solid  gray;\n  }\n\n  button[_ngcontent-%COMP%] {\n  background-color: #8CD4F5;\n  color: white;\n  border: none;\n  box-shadow: none;\n  font-size: 17px;\n  font-weight: 500;\n  -webkit-border-radius: 4px;\n  border-radius: 5px;\n  padding: 10px 32px;\n  margin: 26px 5px 0 5px;\n  cursor: pointer;\n  }\n    \n    button.cancel[_ngcontent-%COMP%] {\n      background-color: #C1C1C1;\n    }"] });
-const ɵMagicConfirmationBoxComponent_BaseFactory = /*@__PURE__*/ ɵɵgetInheritedFactory(MagicConfirmationBoxComponent);
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicConfirmationBoxComponent, [{
+const ɵMagicConfirmationBoxComponent_BaseFactory = ɵɵgetInheritedFactory(MagicConfirmationBoxComponent);
+(function () { ɵsetClassMetadata(MagicConfirmationBoxComponent, [{
         type: Component,
         args: [{
                 selector: 'sample-magic-confirmation-box',
@@ -1136,52 +1294,25 @@ const ɵMagicConfirmationBoxComponent_BaseFactory = /*@__PURE__*/ ɵɵgetInherit
             }]
     }], null, null); })();
 
-/**
- * Service managing overlay windows
- * This is Magic's default provider
- */
-/**
- * Service managing alert and confirmation windows
- * This is Magic's default provider
- */
 class ConfirmationComponentsMagicProvider {
-    /**
-     * Return true when use default javascript alert and confirmation or return false to provide custom components
-     *  @returns true is we want to use default javascript alert and confirmation
-     */
     showDefaultConfirmations() {
         return true;
     }
-    /**
-     * Returns component that will replace javascript alert. The component will be used only if showDefaultConfirmations = false
-     *  @returns component that will replace javascript Alert
-     */
     getAlertComponent() {
         return MagicAlertComponent;
     }
-    /**
-     * Returns component that will replace javascript confirmation box. The component will be used only if showDefaultConfirmations = false
-     *  @returns component that will replace javascript confirmation box
-     */
     getConfirmtionComponent() {
         return MagicConfirmationBoxComponent;
     }
 }
-/** @nocollapse */ ConfirmationComponentsMagicProvider.ɵfac = function ConfirmationComponentsMagicProvider_Factory(t) { return new (t || ConfirmationComponentsMagicProvider)(); };
-/** @nocollapse */ ConfirmationComponentsMagicProvider.ɵprov = ɵɵdefineInjectable({ token: ConfirmationComponentsMagicProvider, factory: ConfirmationComponentsMagicProvider.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(ConfirmationComponentsMagicProvider, [{
+ConfirmationComponentsMagicProvider.ɵfac = function ConfirmationComponentsMagicProvider_Factory(t) { return new (t || ConfirmationComponentsMagicProvider)(); };
+ConfirmationComponentsMagicProvider.ɵprov = ɵɵdefineInjectable({ token: ConfirmationComponentsMagicProvider, factory: ConfirmationComponentsMagicProvider.ɵfac });
+(function () { ɵsetClassMetadata(ConfirmationComponentsMagicProvider, [{
         type: Injectable
     }], null, null); })();
 
-/**
- * Displays a message-box
- */
 class confirmationBox {
-    /**
-     * @ignore
-     */
     static isConfirmBox(style) {
-        // button format mask is in first nibble from right
         let buttonMode = style & 0x0F;
         var isConfirm = (buttonMode === Styles.MSGBOX_BUTTON_OK_CANCEL) ||
             (buttonMode === Styles.MSGBOX_BUTTON_ABORT_RETRY_IGNORE) ||
@@ -1190,14 +1321,7 @@ class confirmationBox {
             (buttonMode === Styles.MSGBOX_BUTTON_RETRY_CANCEL);
         return (isConfirm);
     }
-    /**
-     * Converts the result from the HTML window to the expected result type
-     * @param style Result received from HTML window
-     * @param okWasPressed Was the "OK" pressed
-     * @returns  MessageBox result type
-     */
     static convertToExcpectedResultBox(style, okWasPressed) {
-        // button format mask is in first nibble from right
         let buttonMode = style & 0x0F;
         let retValue = Styles.MSGBOX_RESULT_OK;
         if (buttonMode === Styles.MSGBOX_BUTTON_OK)
@@ -1214,19 +1338,10 @@ class confirmationBox {
             retValue = okWasPressed ? Styles.MSGBOX_RESULT_RETRY : Styles.MSGBOX_RESULT_CANCEL;
         return retValue;
     }
-    /**
-     * Show a message box as an HTML window
-     * @param title Title of the message box
-     * @param message Message that will be display in the message box
-     * @param style Style that include buttons \ Icons
-     * @returns MessageBox result
-     */
     static showConfirmationBox(title, message, style) {
         let okWasPressed = false;
         let retValue = Styles.MSGBOX_RESULT_OK;
-        // check if it is confirmation box
         let isConfirm = this.isConfirmBox(style);
-        // the title will be added to the string and we will add new line after the title
         let titleAndString = title + '\n' + '\n' + message;
         if (isConfirm)
             okWasPressed = confirm(titleAndString);
@@ -1234,14 +1349,10 @@ class confirmationBox {
             alert(titleAndString);
             okWasPressed = true;
         }
-        // return the result from the user
         return okWasPressed;
     }
 }
 
-/**
- * Service managing overlay windows
- */
 class OverlayWindowService {
     constructor(componentFactoryResolver, componentList, engineMagicService, overlayContainerMagicProvider, confirmationComponentsMagicProvider) {
         this.componentFactoryResolver = componentFactoryResolver;
@@ -1256,7 +1367,6 @@ class OverlayWindowService {
         this.overlayWindowFocusManager = new OverlayWindowFocusManager(rootMagicElement);
     }
     open(formName, taskId, taskDescription) {
-        // for overlay which are lazy loaded don't find data in component-list
         let comp = this.componentList.lazyLoadModulesMap != null && this.componentList.lazyLoadModulesMap.hasOwnProperty(formName) ? null : this.componentList.getComponent(formName);
         let parameters = { taskIdParam: taskId, taskDescription: taskDescription };
         let componentRef = this.createModalComponent({ MagicFormName: formName, ModalComp: comp, ModalCompParameters: parameters }, this.overlayContainerMagicProvider.getComponent(), OverlayType.Overlay);
@@ -1267,27 +1377,18 @@ class OverlayWindowService {
         });
     }
     close(commandStr) {
-        // Close the overlay by removing the overlay window from its container
         this.overlayWindowsContainerViewRef.remove();
         this.overlayWindowFocusManager.popDialog();
         let guiEvent1 = getGuiEventObj("dispose", null, 0);
         guiEvent1.TaskID = commandStr;
         this.engineMagicService.insertEvent(guiEvent1);
     }
-    /**
-     * Open Confirmation box
-     * @param title title of the box
-     * @param msg message
-     * @param style Magic style
-     */
     openConfirmationBox(title, msg, style) {
-        //show default confirmations
         if (this.confirmationComponentsMagicProvider.showDefaultConfirmations()) {
             let res = confirmationBox.showConfirmationBox(title, msg, style);
             this.finishConfirmation(style, res);
         }
         else {
-            //show custom confirmations
             let comp = confirmationBox.isConfirmBox(style) ? this.confirmationComponentsMagicProvider.getConfirmtionComponent() : this.confirmationComponentsMagicProvider.getAlertComponent();
             let overlayType = confirmationBox.isConfirmBox(style) ? OverlayType.ConfirmationBox : OverlayType.Alert;
             let componentRef = this.createModalComponent({ title: title, message: msg }, comp, overlayType);
@@ -1298,21 +1399,11 @@ class OverlayWindowService {
             });
         }
     }
-    /**
-     * This method is called on close of the confirmation
-     * @param style Magic style
-     * @param result
-     */
     finishConfirmation(style, result) {
         let guiEvent = getGuiEventObj("confirmationClosed", null, 0);
         guiEvent.keyCode = confirmationBox.convertToExcpectedResultBox(style, result);
         this.engineMagicService.insertEvent(guiEvent);
     }
-    /**
-     * creates a modal component. Can be used for overlay, message box or confirmation box
-     * @param parameters component's parameters
-     * @param component components to create
-     */
     createModalComponent(parameters, component, overlayType) {
         let componentRef;
         let magicModalContainerParameters = {
@@ -1320,20 +1411,18 @@ class OverlayWindowService {
             Parameters: parameters,
             OverlayTypeParam: overlayType
         };
-        // Create the UI component of modal window
         const factory = this.componentFactoryResolver.resolveComponentFactory(MagicOverlayContainerWrapper);
         let viewCRef = this.overlayWindowsContainerViewRef;
         componentRef = viewCRef.createComponent(factory);
-        // Set the data to newly created component
         Object.assign(componentRef.instance, magicModalContainerParameters);
         this.overlayWindowFocusManager.pushDialog(componentRef.instance.GetRootElement());
         componentRef.instance.DetectChanges();
         return componentRef;
     }
 }
-/** @nocollapse */ OverlayWindowService.ɵfac = function OverlayWindowService_Factory(t) { return new (t || OverlayWindowService)(ɵɵinject(ComponentFactoryResolver), ɵɵinject(ComponentListMagicService), ɵɵinject(EngineMagicService), ɵɵinject(OverlayContainerMagicProvider), ɵɵinject(ConfirmationComponentsMagicProvider)); };
-/** @nocollapse */ OverlayWindowService.ɵprov = ɵɵdefineInjectable({ token: OverlayWindowService, factory: OverlayWindowService.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(OverlayWindowService, [{
+OverlayWindowService.ɵfac = function OverlayWindowService_Factory(t) { return new (t || OverlayWindowService)(ɵɵinject(ComponentFactoryResolver), ɵɵinject(ComponentListMagicService), ɵɵinject(EngineMagicService), ɵɵinject(OverlayContainerMagicProvider), ɵɵinject(ConfirmationComponentsMagicProvider)); };
+OverlayWindowService.ɵprov = ɵɵdefineInjectable({ token: OverlayWindowService, factory: OverlayWindowService.ɵfac });
+(function () { ɵsetClassMetadata(OverlayWindowService, [{
         type: Injectable
     }], function () { return [{ type: ComponentFactoryResolver }, { type: ComponentListMagicService }, { type: EngineMagicService }, { type: OverlayContainerMagicProvider }, { type: ConfirmationComponentsMagicProvider }]; }, null); })();
 class OverlayWindowFocusManager {
@@ -1454,95 +1543,37 @@ class DialogInfo {
     }
 }
 
-/**
- * Main service to connect the UI with the Magic WebCLient
- */
 class TaskMagicService {
-    /**
-     *
-     * @param  magic
-     */
     constructor(magic, overlayWindowService) {
         this.magic = magic;
         this.overlayWindowService = overlayWindowService;
-        /**
-         * Collection of data for all controls
-         */
         this.Records = new Records();
-        /**
-         * FormGroup collection for line mode
-         */
         this.formGroups = [];
-        /**
-         * @ignore
-         */
         this.refreshDom = new Subject();
-        /**
-         * @ignore
-         */
         this.detectChanges = new Subject();
-        /**
-         * @ignore
-         */
         this.interactiveCommands = new Subject();
-        /**
-         * @ignore
-         * This event is emitted when the selected row in a table changes.
-         */
         this.OnSelectedRowChanged = new EventEmitter();
-        /**
-         * @ignore
-         */
         this.customPropertiesSubject = new Subject();
-        /**
-         * @ignore
-         */
         this.recordsCountChangeSubject = new Subject();
-        /**
-         * @ignore
-         */
         this.oldPageSize = 0;
         this.Records.setGuiTopIndex(0);
         this.mgInputDateFormat = null;
     }
-    /**
-    * returns true if used is logged in
-    * @returns
-    */
     getIsLoggenIn() {
         return this.magic.getIsLoggedIn();
     }
-    /**
-     * returns the task Id
-     * @returns
-     */
     get taskId() {
         return this._taskId;
     }
-    /**
-     * Sets the task Id
-     * @param value the task id to set
-     */
     set taskId(value) {
-        // debugger;
         this._taskId = value;
     }
-    /**
-     * Returns the task's data in Screen mode
-     * @returns
-     */
     get ScreenControlsData() {
         return this.Records.list['0'];
     }
-    /**
-     * @ignore
-     */
     settemplate(value) {
         this.template = value;
     }
-    /**
-     * Builds the FormControl for each and every control
-     */
     buildScreenModeControls() {
         const group = new FormGroup({});
         for (const key in this.template) {
@@ -1554,21 +1585,10 @@ class TaskMagicService {
         }
         this.ScreenModeControls = group;
     }
-    /**
-     * Is the control a table control
-     * @param id Id of the control
-     * @returns
-     */
     isTableControl(id) {
         return this.template[id] == '1';
     }
     getMgInputDateFormat() { return this.mgInputDateFormat; }
-    /**
-     * Returns the FormControl of a control
-     * @param guiRowid Id of the requested row
-     * @param id Id of the control
-     * @returns
-     */
     getFormControl(guiRowid, id) {
         let c;
         let group = this.isTableControl(id) ? this.formGroups[guiRowid] : this.ScreenModeControls;
@@ -1578,21 +1598,12 @@ class TaskMagicService {
         }
         return c;
     }
-    /**
-     * handle the change of text for input control inside table
-     * @param  guiRowId Id of the row for which the FormControls are built
-     * set the new value of the formcontrol
-     */
     setInputTextValue(controlId, guiRowid, val) {
         this.setValue(controlId, guiRowid, this.ConvertValToNative(controlId, 0, val));
         const fc = this.getFormControl(guiRowid, controlId);
         if (!isNullOrUndefined(val))
             fc.setValue(val);
     }
-    /**
-     * Build the FormControls for a table row
-     * @param  guiRowId Id of the row for which the FormControls are built
-     */
     buildTableRowControls(guiRowId) {
         const group = new FormGroup({});
         for (const key in this.template) {
@@ -1604,58 +1615,30 @@ class TaskMagicService {
         }
         this.formGroups[guiRowId] = group;
     }
-    /**
-     *
-     * @ignore
-     */
     updateRecordsBeforeCurrentView(value) {
         this.Records.recordsBeforeCurrentView = value;
     }
-    /**
-     * @ignore
-     */
     setIncludesFirst(value) {
         this.Records.includesFirst = value;
     }
-    /**
-     * @ignore
-     */
     setIncludesLast(value) {
         this.Records.includesLast = value;
     }
-    /**
-     * @ignore
-     */
     markRowAsCreated(guiRowId) {
         this.Records.markRowAsCreated(guiRowId);
     }
-    /**
-     * @ignore
-     */
     markRowAsNotCreated(guiRowId) {
         this.Records.markRowAsNotCreated(guiRowId);
     }
-    /**
-     * @ignore
-     */
     startRowEditing(guiRowId) {
         this.Records.startRowEditing(guiRowId);
     }
-    /**
-     * @ignore
-     */
     stopRowEditing(guiRowId) {
         this.Records.stopRowEditing(guiRowId);
     }
-    /**
-     * @ignore
-     */
     isRowInRowEditing(guiRowId) {
         return this.Records.isRowInRowEditing(guiRowId);
     }
-    /**
-     * @ignore
-     */
     setIsEmptyDataView(isEmpty) {
         if (this.Records.isEmptyDataView !== isEmpty) {
             if (isEmpty)
@@ -1665,11 +1648,6 @@ class TaskMagicService {
             this.refreshView();
         }
     }
-    /**
-     * Initialize the service to work with the task
-     * @param taskId Id of the task
-     * @param taskDescription
-     */
     initTask(taskId, taskDescription) {
         this.Records.createFirst();
         this.oldPageSize = 0;
@@ -1681,71 +1659,39 @@ class TaskMagicService {
             this.settemplate(taskDescription);
         }
         this.buildScreenModeControls();
-        // remove previous subscriptions
         if (!isNullOrUndefined(this.subscribeRefreshDom))
             this.subscribeRefreshDom.unsubscribe();
         if (!isNullOrUndefined(this.subscribeInteractiveCommands))
             this.subscribeInteractiveCommands.unsubscribe();
         this.subscribeRefreshDom = this.magic.refreshDom.pipe(filter(command => command.TaskTag === this.taskId))
             .subscribe(command => {
-            // console.log("Task " + command.TaskTag + "command " + command.CommandType);
             this.executeCommand(command);
         });
         this.subscribeInteractiveCommands = this.magic.interactiveCommands
             .pipe(filter(command => command.TaskTag === this.taskId))
             .subscribe(command => {
-            // console.log("Task " + command.TaskTag + "command " + command.CommandType);
             this.executeInteractiveCommand(command);
         });
     }
-    /**
-     * @ignore
-     */
     refreshView() {
         this.detectChanges.next('');
     }
-    /**
-     * Insert an event to the Magic WebClient event queue
-     * @param guiEvent The event to insert
-     */
     insertEvent(guiEvent) {
         guiEvent.TaskID = this.taskId;
         this.magic.insertEvent(guiEvent);
     }
-    /**
-     * @ignore
-     */
     GetControlPictureMask(controlName) {
         return this.magic.GetControlPictureMask(this.taskId, controlName);
     }
-    /**
-     * Validates the control value, using the Magic WebClient
-     * @param controlName Id of validated control
-     * @param value value to be validated
-     * @returns If validation fails, returns error message, else returns null
-     */
     ValidateControlValue(controlName, value) {
         return this.magic.ValidateControlValue(this.taskId, controlName, value);
     }
-    /**
-     * @ignore
-     */
     GetRangedValue(controlName, value) {
         return this.magic.GetRangedValue(this.taskId, controlName, value);
     }
-    /**
-     * @ignore
-     */
     GetFldRanges(controlName) {
         return this.magic.GetFldRanges(this.taskId, controlName);
     }
-    /**
-     * returns the value of a property of the control
-     * @param controlId Id of control
-     * @param prop Property
-     * @param guiRowId Row Id, if applicable
-     * @returns Property value
-     */
     getProperty(controlId, prop, guiRowId) {
         if (isNullOrUndefined(guiRowId))
             guiRowId = '0';
@@ -1759,9 +1705,6 @@ class TaskMagicService {
                 return this.Records.list[guiRowId].getProperty(controlId, prop);
         }
     }
-    /**
-     * @ignore
-     */
     getPropertyStub(ControlsProperties, controlId, prop) {
         ControlsProperties = ControlsProperties.ControlsProperties;
         if (controlId in ControlsProperties) {
@@ -1771,31 +1714,15 @@ class TaskMagicService {
         }
         return '';
     }
-    /**
-     * @ignore
-     */
     getStyleStub(ControlsProperties, controlId, styleName) {
         ControlsProperties = ControlsProperties.ControlsProperties;
         return ControlsProperties[controlId].stylesMap.get(styleName);
     }
-    /**
-     * Return the CSS classes used for this control
-     * @param controlId Id of control
-     * @param guiRowId Row Id, if applicable
-     * @returns String containing the classes currently defined for this control
-     */
     getClasses(controlId, guiRowId) {
         if (isNullOrUndefined(guiRowId))
             guiRowId = '0';
         return this.Records.list[guiRowId].getControlMetadata(controlId).classes;
     }
-    /**
-     * Return the value of a style used for a control
-     * @param controlId Id of control
-     * @param styleName Name of style
-     * @param guiRowId Row Id, if applicable
-     * @returns value of style of the control
-     */
     getStyle(controlId, styleName, guiRowId) {
         if (isNullOrUndefined(guiRowId))
             guiRowId = '0';
@@ -1806,36 +1733,21 @@ class TaskMagicService {
             return StylesMapManager.magicValueGetStyle(styleName, magicValue);
         }
     }
-    /**
-     * Return the value of a control
-     * @param controlId Id of control
-     * @param guiRowId Row Id, if applicable
-     * @returns value of the control
-     */
     getValue(controlId, guiRowId) {
         if (isNullOrUndefined(guiRowId))
             guiRowId = '0';
         return this.Records.list.length > +guiRowId ? this.Records.list[guiRowId].values[controlId] : '';
     }
-    /**
-     * Sets the value of a control
-     * @param controlId Id of control
-     * @param guiRowId Row Id, if applicable
-     * @param value Value to set
-     */
+    getFormattedValue(controlName, val) {
+        return this.magic.GetFormattedValue(this.taskId, controlName, val);
+    }
     setValue(controlId, guiRowId, value) {
         return this.Records.list[guiRowId].setValue(controlId, value);
     }
-    /**
-     * @ignore
-     */
     executeInteractiveCommand(guiInteractiveCommand) {
         GuiInteractiveExecutor.executeInteractiveCommand(this, guiInteractiveCommand, this.overlayWindowService);
         this.interactiveCommands.next(guiInteractiveCommand);
     }
-    /**
-     * @ignore
-     */
     handleSetProperty(command, isTableChild) {
         let controlId = command.CtrlName;
         let dvRowId = (command.line || 0);
@@ -1872,7 +1784,6 @@ class TaskMagicService {
         let controlId = command.CtrlName;
         let properties;
         let isTableChild = this.isTableControl(controlId);
-        // For non-input type controls on table.
         if (command.obj !== null)
             isTableChild = isTableChild || command.obj.IsTableChild;
         guiRowId = this.getGuiRowId(dvRowId, isTableChild);
@@ -1923,13 +1834,13 @@ class TaskMagicService {
                 break;
             case CommandType.SET_PROPERTY:
                 this.handleSetProperty(command, isTableChild);
+                if (command.Operation == HtmlProperties.ReadOnly)
+                    this.refreshDom.next(command);
                 break;
             case CommandType.PROP_SET_USER_PROPERTY:
                 properties = this.Records.list[guiRowId].getControlMetadata(controlId);
-                // if the property has changed, set the property and raise the subject
                 if (properties.userProperties.get(command.Operation) !== command.obj1) {
                     properties.userProperties.set(command.Operation, command.obj1);
-                    // the property name is of format <controlName>~<propertyName>
                     this.customPropertiesSubject.next({ propertyName: controlId + '~' + command.Operation, value: command.obj1, rowId: guiRowId });
                 }
                 break;
@@ -1955,7 +1866,7 @@ class TaskMagicService {
                 properties.setStyle(command.Operation, command.obj1);
                 break;
             case CommandType.SET_ATTRIBUTE:
-                properties = this.Records.list[guiRowId].getControlMetadata(controlId);
+                properties = this.Records.list[0].getControlMetadata(controlId);
                 properties.dataType = String.fromCharCode(command.number);
                 break;
             case CommandType.SET_VALUE:
@@ -1974,12 +1885,11 @@ class TaskMagicService {
             case CommandType.SET_EMPTY_DATAVIEW:
                 this.setIsEmptyDataView(command.Bool1);
                 break;
+            case CommandType.SET_FOCUS:
+                this.refreshDom.next(command);
+                break;
         }
-        this.refreshDom.next(command);
     }
-    /**
-    custom validator
-    */
     customValidator(rowid, id) {
         return (control) => {
             let controlMetadata;
@@ -1993,13 +1903,6 @@ class TaskMagicService {
             return null;
         };
     }
-    /**
-     * COnvert a value from Magic format to native format
-     * @param controlId Id of control
-     * @param  rowId Row Id, if applicable
-     * @param val Value to convert
-     * @returns Converted value
-     */
     ConvertValToNative(controlId, rowId, val) {
         let properties;
         properties = this.Records.list[0].getControlMetadata(controlId);
@@ -2048,13 +1951,6 @@ class TaskMagicService {
                 return val;
         }
     }
-    /**
-     * Convert a value from native to Magic format
-     * @param controlId Id of control
-     * @param  rowId Row Id, if applicable
-     * @param val Value to convert
-     * @returns Converted value
-     */
     ConvertValFromNative(controlId, rowId, val) {
         let properties;
         properties = this.Records.list[0].getControlMetadata(controlId);
@@ -2097,22 +1993,12 @@ class TaskMagicService {
                 return val;
         }
     }
-    /**
-     * Handle resize and also fetch chunk of records if having an empty view.
-     * @ignore
-     * @param pageSize : PageSize
-     * @param topGuiRowId : GuiRowId of first record in view.
-     */
     resize(pageSize, topGuiRowId) {
         let guiEvent = getGuiEventObj('resize', 'table', 0);
         guiEvent.PageSize = pageSize;
-        //As 'getRows' event also gets executed, set the guiEvent.Line parameter.
         guiEvent.Line = topGuiRowId;
         this.insertEvent(guiEvent);
     }
-    /**
-     * Fetches data for new table rows when scrolling done
-     */
     onScrollDown() {
         if (!this.Records.includesLast) {
             let guiEvent = getGuiEventObj('getRows', 'table', 0);
@@ -2120,29 +2006,15 @@ class TaskMagicService {
             this.insertEvent(guiEvent);
         }
     }
-    /**
-     * Sets the new browser window title
-     * @param newTitle New window title
-     */
     setTitle(newTitle) {
         this.mgTitleService.setTitle(newTitle);
     }
-    /**
-     * @ignore
-     */
     getGuiRowId(dvRowId, isTableControl) {
         return (isTableControl ? dvRowId + this.Records.recordsBeforeCurrentView : 0);
     }
-    /**
-     *
-     * @ignore
-     */
     getDvRowId(guiRowId) {
         return (guiRowId - this.Records.recordsBeforeCurrentView);
     }
-    /**
-     * Clean up the service when it is no longer needed
-     */
     dispose() {
         this.refreshDom.complete();
         this.detectChanges.complete();
@@ -2152,14 +2024,6 @@ class TaskMagicService {
         this.customPropertiesSubject.complete();
         this.OnSelectedRowChanged.complete();
     }
-    ///////////////////////////////
-    //Events:
-    /**
-     * Handle the Combobox "change" event
-     * @param event  The event received from the UI
-     * @param idx Id of the control raising the event
-     * @param line Row Id, if applicable
-     */
     onComboboxSelectionChanged(event, idx, line) {
         let guiEvent = getGuiEventObj('selectionchanged', idx, line);
         if (typeof (event) == 'number') {
@@ -2167,467 +2031,136 @@ class TaskMagicService {
         }
         else {
             if (!isNullOrUndefined(event.target)) {
-                let indexes = new Array(event.target.selectedOptions.length);
-                for (let i = 0; i < event.target.selectedOptions.length; i++) {
-                    indexes[i] = event.target.selectedOptions[i].index;
-                }
-                guiEvent.Value = indexes.join(',');
-            }
-            else
-                guiEvent.Value = event.value;
-        }
-        this.insertEvent(guiEvent);
-    }
-    /**
-     * Handle the Listbox "change" event
-     * @param  event The event received from the UI
-     * @param idx Id of the control raising the event
-     */
-    onListBoxSelectionChanged(event, idx) {
-        let guiEvent = getGuiEventObj('selectionchanged', idx, 0);
-        let selectedOptions;
-        if (!isNullOrUndefined(event.target))
-            selectedOptions = event.target.selectedOptions;
-        else
-            selectedOptions = event.source.selectedOptions.selected;
-        let length = selectedOptions.length;
-        let indexes = new Array(length);
-        for (let i = 0; i < length; i++) {
-            if (!isNullOrUndefined(event.target))
-                indexes[i] = (selectedOptions[i]).index;
-            else
-                indexes[i] = (selectedOptions[i]).value;
-        }
-        guiEvent.Value = indexes; // TODO: fix
-        this.insertEvent(guiEvent);
-    }
-    /**
-     * Handle the Checkbox "change" event
-     * @param  event The event received from the UI
-     * @param idx Id of the control raising the event
-     * @param  rowId Row Id, if applicable
-     */
-    onCheckChanged(event, idx, rowId) {
-        if (typeof rowId === 'undefined')
-            rowId = 0;
-        let guiEvent = getGuiEventObj('selectionchanged', idx, rowId);
-        if (typeof (event) == 'boolean') {
-            guiEvent.Value = event;
-        }
-        else {
-            if (typeof event.target === 'undefined')
-                guiEvent.Value = (event).checked;
-            else
-                guiEvent.Value = (event.target).checked;
-        }
-        this.insertEvent(guiEvent);
-    }
-    /**
-     * Handle tab selection change, caused by UI events
-     * @param idx Id of the control raising the event
-     * @param  layer Id of selected tabpage
-     */
-    mgOnTabSelectionChanged(idx, layer) {
-        let guiEvent = getGuiEventObj('selectionchanged', idx, 0);
-        guiEvent.Value = layer.toString();
-        this.insertEvent(guiEvent);
-    }
-    /**
-     * Handle the Radio button "change" event
-     * @param  event The event received from the UI
-     * @param idx Id of the control raising the event
-     */
-    mgOnRadioSelectionChanged(event, idx) {
-        let result = this.getFormControl('0', idx);
-        let guiEvent = getGuiEventObj('selectionchanged', idx, 0);
-        if (typeof result.value !== 'string')
-            guiEvent.Value = result.value.index;
-        else
-            guiEvent.Value = result.value;
-        this.insertEvent(guiEvent);
-    }
-    /**
-     * Inserts the "close" event to the magic WebClient event queue
-     */
-    close() {
-        this.insertEvent(getGuiEventObj('close', null, 0));
-    }
-    ///////////////////////////////
-    /**
-     * @ignore
-     */
-    IsStub() {
-        return this.magic.isStub;
-    }
-    /**
-     * @ignore
-     */
-    saveData(data) {
-        this.magic.saveData(data);
-    }
-    /**
-     * @ignore
-     */
-    createData() {
-        let myData = {
-            records: this.Records,
-            template: this.template
-        };
-        let text = 'loadData():any   {\n' +
-            '    let stubData = ' + JSON.stringify(myData) + ';\n' +
-            '    this.loadStubData(stubData);}';
-        console.log(text);
-        this.saveData(text);
-    }
-    /**
-     * @ignore
-     */
-    loadStubData(stubData) {
-        this.Records = stubData.records;
-        this.settemplate(stubData.template);
-        this.taskId = '1';
-        for (let i = 0; i < this.Records.list.length; i++)
-            this.buildTableRowControls(i);
-    }
-    /**
-     * @ignore
-     */
-    loadData() {
-        alert('Please, overwrite method loadData');
-    }
-    /**
-     * @ignore
-     */
-    setStubValue(guiRowId, fc, name) {
-        if (this.IsStub()) {
-            try {
-                let val = this.Records.list[guiRowId].values[name];
-                fc.setValue(val);
-            }
-            catch (e) {
-            }
-        }
-    }
-}
-/** @nocollapse */ TaskMagicService.ɵfac = function TaskMagicService_Factory(t) { return new (t || TaskMagicService)(ɵɵinject(EngineMagicService), ɵɵinject(OverlayWindowService)); };
-/** @nocollapse */ TaskMagicService.ɵprov = ɵɵdefineInjectable({ token: TaskMagicService, factory: TaskMagicService.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(TaskMagicService, [{
-        type: Injectable
-    }], function () { return [{ type: EngineMagicService }, { type: OverlayWindowService }]; }, null); })();
-
-/**
- * @ignore
- */
-class CommandsCollectorMagicService {
-    constructor(magic) {
-        this.magic = magic;
-        this.count = 0;
-        this.commands = new List();
-        this.subscription = null;
-    }
-    startCollecting() {
-        this.count++;
-        Logger.Instance.WriteDevToLog("CommandsCollectorMagicService.startCollecting() --- " + this.count);
-        if (this.subscription === null) {
-            this.subscription = this.magic.refreshDom
-                .subscribe(command => {
-                this.commands.push(command);
-            });
-        }
-    }
-    stopCollecting() {
-        this.count--;
-        Logger.Instance.WriteDevToLog("CommandsCollectorMagicService.stopCollecting() --- " + this.count);
-        if (this.count === 0) {
-            this.subscription.unsubscribe();
-            this.subscription = null;
-        }
-    }
-    GetCommands(taskId) {
-        const commands = this.commands.filter((command) => command.TaskTag === taskId);
-        commands.forEach(command => { this.commands.Remove(command); });
-        return commands;
-    }
-}
-/** @nocollapse */ CommandsCollectorMagicService.ɵfac = function CommandsCollectorMagicService_Factory(t) { return new (t || CommandsCollectorMagicService)(ɵɵinject(EngineMagicService)); };
-/** @nocollapse */ CommandsCollectorMagicService.ɵprov = ɵɵdefineInjectable({ token: CommandsCollectorMagicService, factory: CommandsCollectorMagicService.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(CommandsCollectorMagicService, [{
-        type: Injectable
-    }], function () { return [{ type: EngineMagicService }]; }, null); })();
-
-/**
- * @ignore
- */
-class RouteCommand {
-}
-/**
- * @ignore
- */
-class RouterCommandsMagicService {
-    constructor() {
-        this.pendingRouteCommands = [];
-    }
-    AddRouteCommand(routeCommand) {
-        this.pendingRouteCommands.push(routeCommand);
-    }
-    ExecuteNextCommand() {
-        let pendingRouteCommand = this.pendingRouteCommands.shift();
-        if (!isNullOrUndefined(pendingRouteCommand)) {
-            pendingRouteCommand.callerMgSubformServiceRef.ExecuteRouteCommand(pendingRouteCommand);
-        }
-    }
-}
-/** @nocollapse */ RouterCommandsMagicService.ɵfac = function RouterCommandsMagicService_Factory(t) { return new (t || RouterCommandsMagicService)(); };
-/** @nocollapse */ RouterCommandsMagicService.ɵprov = ɵɵdefineInjectable({ token: RouterCommandsMagicService, factory: RouterCommandsMagicService.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(RouterCommandsMagicService, [{
-        type: Injectable
-    }], null, null); })();
-
-/**
- * Service for managing subforms and routing
- */
-class SubformMagicService {
-    constructor(task, activatedRoute, componentList, pendingCommandsCollector, router, routerCommandsMagicService) {
-        this.task = task;
-        this.activatedRoute = activatedRoute;
-        this.componentList = componentList;
-        this.pendingCommandsCollector = pendingCommandsCollector;
-        this.router = router;
-        this.routerCommandsMagicService = routerCommandsMagicService;
-        this.subformsDict /*:{ [x: string]: SubformDefinition }*/ = {};
-        this.routesDict = {}; // dictionary of router outlet to router path
-        this.currentRouteDefinition = null;
-    }
-    /**
-     * Finds and returns the component according to the subform name
-     * @param subformName
-     * @returns
-     */
-    mgGetComp(subformName) {
-        if (subformName in this.subformsDict) {
-            let formName = this.subformsDict[subformName].formName;
-            if (formName)
-                return this.componentList.getComponent(formName);
-        }
-        return null;
-    }
-    /**
-     * Returns the parameters of the subform
-     * @param subformName
-     * @returns
-     */
-    mgGetParameters(subformName) {
-        if (subformName in this.subformsDict) {
-            return this.subformsDict[subformName].parameters;
-        }
-        else
-            return "";
-    }
-    /**
-     * @ignore
-     */
-    deleteSubformComp(subformControlName, formName) {
-        if (Object.keys(this.subformsDict).indexOf(subformControlName) >= 0) {
-            if (this.subformsDict[subformControlName].formName === formName) {
-                this.subformsDict[subformControlName] = {};
-                this.task.refreshView();
-            }
-        }
-    }
-    /**
-     * @ignore
-     */
-    addSubformComp(subformControlName, formName, taskId, taskDescription, routerPath, params, inDefaultOutlet) {
-        this.pendingCommandsCollector.startCollecting();
-        let refreshNeeded = false;
-        if (isNullOrUndefined(routerPath)) { // call in destination subform
-            if (Object.keys(this.subformsDict).indexOf(subformControlName) >= 0) {
-                if (this.subformsDict[subformControlName].formName === formName) {
-                    this.subformsDict[subformControlName] = {};
-                    this.task.refreshView();
-                }
-            }
-            this.subformsDict[subformControlName] = {
-                formName,
-                parameters: { taskIdParam: taskId, taskDescription: taskDescription }
-            };
-            //this.ref.detectChanges();
-            refreshNeeded = true;
-        }
-        else { // call route
-            if (inDefaultOutlet)
-                subformControlName = "primary";
-            let routeParams = new List();
-            routeParams.push(routerPath);
-            if (params !== null) {
-                routeParams = routeParams.concat(params);
+                let indexes = new Array(event.target.selectedOptions.length);
+                for (let i = 0; i < event.target.selectedOptions.length; i++) {
+                    indexes[i] = event.target.selectedOptions[i].index;
+                }
+                guiEvent.Value = indexes.join(',');
             }
-            let routeCommand = {
-                callerMgSubformServiceRef: this,
-                routerOutletName: subformControlName,
-                formName: formName,
-                parameters: { taskIdParam: taskId, taskDescription: taskDescription },
-                routeParams: routeParams
-            };
-            // If SubformMagicService.currentCallerMgSubformServiceRef !== null means that router.navigate() is already
-            // called once, but angular has not yet executed it (ngOnInit of the new component is not called).
-            // In such a case, do not executed router.navigate() again. Because, angular ignores the previous one.
-            // So, put a command in the queue which will be executed after the first one is executed.
-            if (SubformMagicService.currentCallerMgSubformServiceRef === null)
-                this.ExecuteRouteCommand(routeCommand);
             else
-                this.routerCommandsMagicService.AddRouteCommand(routeCommand);
+                guiEvent.Value = event.value;
         }
-        if (refreshNeeded)
-            this.task.refreshView();
+        this.insertEvent(guiEvent);
     }
-    /**
-     * Open the subform using a route command
-     */
-    ExecuteRouteCommand(routeCommand) {
-        let reusingComponent = false;
-        let currentSubformMagicService = routeCommand.callerMgSubformServiceRef;
-        let relativeRoute = SubformMagicService.getRelativeRoute(currentSubformMagicService.activatedRoute);
-        if (currentSubformMagicService.routesDict[routeCommand.routerOutletName] === routeCommand.routeParams[0]) {
-            // If the specified router outlet already hosts the same router path, router.navigate() doesn't actually navigate.
-            // So, first clear the outlet (passing null route params, clears the outlet) and then navigate again.
-            currentSubformMagicService.router.navigate([{ outlets: { [routeCommand.routerOutletName]: null } }], { relativeTo: relativeRoute })
-                .then((result) => {
-                SubformMagicService.currentCallerMgSubformServiceRef = currentSubformMagicService;
-                currentSubformMagicService.currentRouteDefinition = {
-                    formName: routeCommand.formName,
-                    parameters: routeCommand.parameters
-                };
-                currentSubformMagicService.PerformRouterNavigate(routeCommand.routerOutletName, routeCommand.routeParams);
-            });
+    onListBoxSelectionChanged(event, idx) {
+        let guiEvent = getGuiEventObj('selectionchanged', idx, 0);
+        let selectedOptions;
+        if (!isNullOrUndefined(event.target))
+            selectedOptions = event.target.selectedOptions;
+        else
+            selectedOptions = event.source.selectedOptions.selected;
+        let length = selectedOptions.length;
+        let indexes = new Array(length);
+        for (let i = 0; i < length; i++) {
+            if (!isNullOrUndefined(event.target))
+                indexes[i] = (selectedOptions[i]).index;
+            else
+                indexes[i] = (selectedOptions[i]).value;
+        }
+        guiEvent.Value = indexes;
+        this.insertEvent(guiEvent);
+    }
+    onCheckChanged(event, idx, rowId) {
+        if (typeof rowId === 'undefined')
+            rowId = 0;
+        let guiEvent = getGuiEventObj('selectionchanged', idx, rowId);
+        if (typeof (event) == 'boolean') {
+            guiEvent.Value = event;
         }
         else {
-            SubformMagicService.currentCallerMgSubformServiceRef = currentSubformMagicService;
-            currentSubformMagicService.currentRouteDefinition = {
-                formName: routeCommand.formName,
-                parameters: routeCommand.parameters
-            };
-            if (SubformMagicService.routerContainers.length > 0) {
-                let routeContainer = SubformMagicService.routerContainers[0];
-                SubformMagicService.routerContainers.shift();
-                routeContainer.initializeComponent();
-            }
-            else {
-                currentSubformMagicService.PerformRouterNavigate(routeCommand.routerOutletName, routeCommand.routeParams);
-            }
+            if (typeof event.target === 'undefined')
+                guiEvent.Value = (event).checked;
+            else
+                guiEvent.Value = (event.target).checked;
         }
+        this.insertEvent(guiEvent);
     }
-    PerformRouterNavigate(routerOutletName, routeParams) {
-        let relativeRoute = SubformMagicService.getRelativeRoute(this.activatedRoute);
-        this.router.navigate([{ outlets: { [routerOutletName]: routeParams } }], { relativeTo: relativeRoute })
-            .then((result) => {
-            if (result !== null && !result) {
-                let subformMagicService = SubformMagicService.currentCallerMgSubformServiceRef;
-                subformMagicService.currentRouteDefinition = null;
-                SubformMagicService.currentCallerMgSubformServiceRef = null;
-                subformMagicService.pendingCommandsCollector.stopCollecting();
-                subformMagicService.routerCommandsMagicService.ExecuteNextCommand();
-            }
-        });
+    mgOnTabSelectionChanged(idx, layer) {
+        let guiEvent = getGuiEventObj('selectionchanged', idx, 0);
+        guiEvent.Value = layer.toString();
+        this.insertEvent(guiEvent);
     }
-    /**
-     * @ignore
-     */
-    init() {
-        // If commands were issued for this task before ngOnInit(), they were not executed because task had not registered for them.
-        // So, execute them now.
-        const pendingCommands = this.pendingCommandsCollector.GetCommands(this.task.taskId);
-        if (pendingCommands.length > 0) {
-            pendingCommands.forEach(command => { this.task.executeCommand(command); });
-            this.task.refreshView();
-        }
-        this.pendingCommandsCollector.stopCollecting();
+    mgOnRadioSelectionChanged(event, idx) {
+        let result = this.getFormControl('0', idx);
+        let guiEvent = getGuiEventObj('selectionchanged', idx, 0);
+        if (typeof result.value !== 'string')
+            guiEvent.Value = result.value.index;
+        else
+            guiEvent.Value = result.value;
+        this.insertEvent(guiEvent);
     }
-    /**
-     * @ignore
-     */
-    refreshView() {
-        this.task.refreshView();
+    close() {
+        this.insertEvent(getGuiEventObj('close', null, 0));
     }
-    ///
-    // return the relative route
-    //
-    static getRelativeRoute(sendActivatedRoute) {
-        let currentActiveRoute = sendActivatedRoute;
-        if (currentActiveRoute.snapshot.routeConfig !== null && currentActiveRoute.snapshot.routeConfig.path === '') {
-            currentActiveRoute = currentActiveRoute.parent;
-            if (!currentActiveRoute.snapshot.routeConfig.loadChildren)
-                console.log("getRelativeRoute(): both path and currentActiveRoute.snapshot.routeConfig.loadChildren are empty.");
+    IsStub() {
+        return this.magic.isStub;
+    }
+    saveData(data) {
+        this.magic.saveData(data);
+    }
+    createData() {
+        let myData = {
+            records: this.Records,
+            template: this.template
+        };
+        let text = 'loadData():any   {\n' +
+            '    let stubData = ' + JSON.stringify(myData) + ';\n' +
+            '    this.loadStubData(stubData);}';
+        console.log(text);
+        this.saveData(text);
+    }
+    loadStubData(stubData) {
+        this.Records = stubData.records;
+        this.settemplate(stubData.template);
+        this.taskId = '1';
+        for (let i = 0; i < this.Records.list.length; i++)
+            this.buildTableRowControls(i);
+    }
+    loadData() {
+        alert('Please, overwrite method loadData');
+    }
+    setStubValue(guiRowId, fc, name) {
+        if (this.IsStub()) {
+            try {
+                let val = this.Records.list[guiRowId].values[name];
+                fc.setValue(val);
+            }
+            catch (e) {
+            }
         }
-        return currentActiveRoute;
     }
 }
-SubformMagicService.currentCallerMgSubformServiceRef = null;
-SubformMagicService.routerContainers = new Array();
-/** @nocollapse */ SubformMagicService.ɵfac = function SubformMagicService_Factory(t) { return new (t || SubformMagicService)(ɵɵinject(TaskMagicService), ɵɵinject(ActivatedRoute), ɵɵinject(ComponentListMagicService), ɵɵinject(CommandsCollectorMagicService), ɵɵinject(Router), ɵɵinject(RouterCommandsMagicService)); };
-/** @nocollapse */ SubformMagicService.ɵprov = ɵɵdefineInjectable({ token: SubformMagicService, factory: SubformMagicService.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(SubformMagicService, [{
+TaskMagicService.ɵfac = function TaskMagicService_Factory(t) { return new (t || TaskMagicService)(ɵɵinject(EngineMagicService), ɵɵinject(OverlayWindowService)); };
+TaskMagicService.ɵprov = ɵɵdefineInjectable({ token: TaskMagicService, factory: TaskMagicService.ɵfac });
+(function () { ɵsetClassMetadata(TaskMagicService, [{
         type: Injectable
-    }], function () { return [{ type: TaskMagicService }, { type: ActivatedRoute }, { type: ComponentListMagicService }, { type: CommandsCollectorMagicService }, { type: Router }, { type: RouterCommandsMagicService }]; }, null); })();
+    }], function () { return [{ type: EngineMagicService }, { type: OverlayWindowService }]; }, null); })();
 
-/**
- * Implements various table-related functionalities
- */
 class TableMagicService {
-    /**
-     *
-     * @param componentList Component-mapping service
-     * @param task Magic task service
-     */
     constructor(componentList, task) {
         this.componentList = componentList;
         this.task = task;
         this.shouldOpenFieldTextEditor = true;
     }
-    /**
-     * Refreshes the DataSource
-     */
     refreshDataSource() {
     }
-    /**
-     * Returns the table page size
-     */
     getPageSize() {
         return 10;
     }
-    /**
-     * Returns max no of rows in the table.
-     */
     getMaxRowsInTable() {
         return this.task.Records.list.length;
     }
-    /**
-     * Selects the specified row
-     * @param rowId The row to select
-     */
     selectRow(rowId) {
         this.selectedItem = rowId;
     }
     getSelectedRow() {
         return this.selectedItem;
     }
-    /**
-     * Returns the selected row
-     */
     selectedRow() {
         return null;
     }
-    /**
-     * Selects the specified page
-     * @param  pageId The page to select
-     */
     selectPage(pageId) {
     }
-    /**
-     * Returns whether a dialog should be opened for the HTML element
-     * @param  element The HTML element for which a dialog may be needed
-     * @returns
-     */
     OpenDialogForControl(element) {
         if (element.tagName === "MAT-SELECT" || element.tagName === "MAT-CHECKBOX" ||
             element.tagName === "INPUT" ||
@@ -2635,34 +2168,17 @@ class TableMagicService {
             return false;
         return true;
     }
-    /**
-     * Returns the dialog used to edit values
-     */
     getDialog() {
         return null;
     }
-    /**
-     * Handles the table "scrolled" event
-     */
     onScrollDown() {
         this.task.onScrollDown();
     }
-    /**
-     * To be overwitten in specific implelemtations
-     */
     sortData(e) { }
-    /**
-     * To be overwitten in specific implelemtations
-     */
     mgOnPaginateChange(e) { }
     mgOptionChanged(e) { }
-    /**
-     * Change the number of lines in a table
-     * @param  size New number of lines in table
-     */
     updateTableSize(size) {
-        if (size === 0) // never remove row 0 for now
-         {
+        if (size === 0) {
             size = 1;
             this.task.Records.clearFirstTableRecord(this.task.template);
         }
@@ -2670,17 +2186,11 @@ class TableMagicService {
         this.task.Records.updateSize(size);
         this.task.setIncludesFirst(false);
     }
-    /**
-     * @ignore
-     */
     setTableTopIndex(value) {
         if (!this.task.Records.includesFirst)
             value++;
         this.task.Records.setGuiTopIndex(value);
     }
-    /**
-     * @ignore
-     */
     getTableTopIndex() {
         let topIndex = this.task.Records.getGuiTopIndex();
         if (!this.task.Records.includesFirst)
@@ -2688,55 +2198,32 @@ class TableMagicService {
         return topIndex;
     }
 }
-/** @nocollapse */ TableMagicService.ɵfac = function TableMagicService_Factory(t) { return new (t || TableMagicService)(ɵɵinject(ComponentListMagicService), ɵɵinject(TaskMagicService)); };
-/** @nocollapse */ TableMagicService.ɵprov = ɵɵdefineInjectable({ token: TableMagicService, factory: TableMagicService.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(TableMagicService, [{
+TableMagicService.ɵfac = function TableMagicService_Factory(t) { return new (t || TableMagicService)(ɵɵinject(ComponentListMagicService), ɵɵinject(TaskMagicService)); };
+TableMagicService.ɵprov = ɵɵdefineInjectable({ token: TableMagicService, factory: TableMagicService.ɵfac });
+(function () { ɵsetClassMetadata(TableMagicService, [{
         type: Injectable
     }], function () { return [{ type: ComponentListMagicService }, { type: TaskMagicService }]; }, null); })();
 
-/**
- * Enables changing the browser title using Magic expression (SetTitle)
- */
 class TitleMagicService {
-    /**
-     *
-     * @param titleService Angular's title-changing class
-     */
     constructor(titleService) {
         this.titleService = titleService;
     }
-    /**
-     * Set the new title of the window
-      * @param newTitle New title of the window
-     */
     setTitle(newTitle) {
         this.titleService.setTitle(newTitle);
     }
 }
-/** @nocollapse */ TitleMagicService.ɵfac = function TitleMagicService_Factory(t) { return new (t || TitleMagicService)(ɵɵinject(Title)); };
-/** @nocollapse */ TitleMagicService.ɵprov = ɵɵdefineInjectable({ token: TitleMagicService, factory: TitleMagicService.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(TitleMagicService, [{
+TitleMagicService.ɵfac = function TitleMagicService_Factory(t) { return new (t || TitleMagicService)(ɵɵinject(Title)); };
+TitleMagicService.ɵprov = ɵɵdefineInjectable({ token: TitleMagicService, factory: TitleMagicService.ɵfac });
+(function () { ɵsetClassMetadata(TitleMagicService, [{
         type: Injectable
     }], function () { return [{ type: Title }]; }, null); })();
 
-/**
- * Provides the UI with values calculated by the Magic WebClient
- */
 class AccessorMagicService {
-    /**
-     * @ignore
-     */
     constructor(task) {
         this.task = task;
         this.Logger = null;
         this.Logger = Logger.Instance;
     }
-    /**
-     * Checks if the control is read-only
-     * @param controlId Id of control
-     * @returns Is the control not read-only
-     */
-    // CheckReadOnly
     checkIsReadOnly(controlId) {
         let properties;
         properties = this.task.Records.list[0].getControlMetadata(controlId);
@@ -2745,99 +2232,45 @@ class AccessorMagicService {
         else
             return true;
     }
-    /**
-     * Returns the text of the control
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns The text of the control
-     */
-    // mgGetText
     getText(controlId, rowId) {
         return this.task.getProperty(controlId, HtmlProperties.Text, rowId);
     }
-    /**
-     * Gets the text of the tab page
-     * @param controlId Id of control
-     * @param layer Id of tabpage
-     * @returns Text of tabpage
-     */
-    // mgGetTabpageText
     getTabpageText(controlId, layer) {
         const items = this.task.getProperty(controlId, HtmlProperties.ItemsList);
         if (typeof items !== "undefined")
             return items[layer].displayValue;
         return "";
     }
-    /**
-     * Gets the image defined for the control
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns Image set on control
-     */
-    // mgGetImage
     getImage(controlId, rowId) {
         let result = this.task.getProperty(controlId, HtmlProperties.Image, rowId);
         return result;
     }
-    /**
-     * Returns whether an image is set for this control
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns returns true if control has an image set on it
-     */
-    // mgIsImageExists
     isImageExists(controlId, rowId) {
         let result = this.task.getProperty(controlId, HtmlProperties.Image, rowId);
         return !isNullOrUndefined(result);
     }
-    /**
-     * Gets the CSS classes set on the control
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns The classes for this control
-     */
-    // mgGetClasses
     getClasses(controlId, rowId) {
         return this.task.getClasses(controlId, rowId);
     }
-    /**
-     * Gets the CSS styles set on the control
-     * @param controlId Id of control
-     * @param styleName NAme of style requested
-     * @param rowId Id of row, if applicable
-     * @returns The style set on the control
-     */
-    // mgGetStyle
     getStyle(controlId, styleName, rowId) {
         let style = this.task.getStyle(controlId, styleName, rowId);
         return style;
     }
-    /**
-     * Returns whether a control is visible or not
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns Is the control visible or hidden
-     */
-    // mgGetVisible
     getVisible(controlId, rowId) {
         let vis = this.getProperty(controlId, HtmlProperties.Visible, rowId);
         return vis ? 'visible' : 'hidden';
     }
-    /**
-     * Returns object representing numeric picture
-     * @param picture string which is defined in magic
-     * @returns object representing numeric picture
-     */
-    // mgGetNumericPicture
     getNumericPicture(picture) {
         if (isNullOrUndefined(picture))
             return null;
         let pic = new PIC(picture, StorageAttribute.NUMERIC, 0);
         var obj = {};
-        if (pic.getPosPref_().length > 0)
-            obj['prefix'] = pic.getPosPref_();
-        else
-            obj['prefix'] = "";
+        obj['prefix'] = "";
+        if (pic.getPosPref_().length > 0 && pic.getNegPref_().length > 0) {
+            let pref = '-' + pic.getPosPref_();
+            if (pref == pic.getNegPref_())
+                obj['prefix'] = pic.getPosPref_();
+        }
         if (pic.getPosSuff_().length > 0)
             obj['suffix'] = pic.getPosSuff_();
         else
@@ -2859,128 +2292,51 @@ class AccessorMagicService {
             obj['wholes'] = pic.getWholes();
         return obj;
     }
-    /**
-     * Returns whether a control should have the "required" attribute set on it
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    // mgGetMustInput
     getMustInput(controlId, rowId) {
         let vis = this.getProperty(controlId, HtmlProperties.MustInput, rowId);
         return vis ? 'true' : 'false';
     }
-    /**
-     * Returns whether a control is disabled
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    // mgIsDisabled
     isDisabled(controlId, rowId) {
         let result = this.getProperty(controlId, HtmlProperties.Enabled, rowId);
         return result === true ? null : true;
     }
-    /**
-     * @ignore
-     */
-    // getProperty (not changed)
     getProperty(controlId, prop, rowId) {
         return this.task.getProperty(controlId, prop, rowId);
     }
-    /**
-     * Returns the title (tooltip) text of the control
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    // mgGetTitle
     getTitle(controlId, rowId) {
         return this.task.getProperty(controlId, HtmlProperties.Tooltip, rowId);
     }
-    /**
-     * Returns the title (tooltip) text of the control
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    // mgGetTitle for zoom button
     getZoomButtonTitle(controlId, rowId) {
         return this.task.getProperty(controlId, HtmlProperties.ZoomButtonTooltip, rowId);
     }
-    /**
-     * Gets the selection control's selected value
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    // getSelectedValue
     getSelectedValue(controlId, rowId) {
         return this.task.getProperty(controlId, HtmlProperties.SelectedValue, rowId);
     }
-    /**
-     * Gets the place-holder text of the control
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    // mgGetPlaceholder
     getPlaceholder(controlId, rowId) {
         return this.task.getProperty(controlId, HtmlProperties.PlaceHolder, rowId);
     }
-    /**
-     * Returns a type for input controls - should the control be a simple text or a password control
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    // mgGetType
     getType(controlId, rowId) {
         let result = this.task.getProperty(controlId, HtmlProperties.Password, rowId);
         return result ? "password" : "text";
     }
-    /**
-     * Returns the tab-index of the control
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    // mgGetTabIndex
     getTabIndex(controlId, rowId) {
         return this.task.getProperty(controlId, HtmlProperties.TabIndex, rowId);
     }
-    /**
-     * Returns the value of the control
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    /// mgGetValue -->
     getValue(controlId, rowId) {
         let val = this.task.getValue(controlId, rowId);
         return val;
     }
-    /**
-     * Returns the Picture of the control
-     * @param controlId Id of control
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    /// getPicture -->
+    getFormattedValue(controlId, rowId) {
+        let val = this.task.getValue(controlId, rowId);
+        val = this.task.getFormattedValue(controlId, val);
+        return val;
+    }
     getPicture(controlId, rowId) {
         if (isNullOrUndefined(controlId))
             return null;
         let pic = this.task.GetControlPictureMask(controlId);
         return (pic != null) ? pic.getFormat().toString() : null;
     }
-    /**
-     * Returns the custom (user) properties of the control
-     * @param controlId Id of control
-     * @param propertyName Name of requested property
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    // mgGetCustomProperty
     getCustomProperty(controlId, propertyNameOrRowID, rowId) {
         if (controlId.indexOf('~') == -1)
             return this.getCustomProperty_1(controlId, propertyNameOrRowID, rowId);
@@ -3005,22 +2361,21 @@ class AccessorMagicService {
         }
         return userProperties;
     }
-    /**
-     * Gets the values of the items of a selection control
-     * @param id Id of control
-     * @param rowId Id of row, if applicable
-     * @returns
-     */
-    // mgGetItemListValues
     getItemListValues(id, rowId) {
         return this.getProperty(id, HtmlProperties.ItemsList, rowId);
     }
-    /**
-   * Gets the display value of the item from items of a selection control
-   * @param id Id of control
-   * @param rowId Id of row, if applicable
-   * @returns
-   */
+    getFilteredList(controlId, rowId) {
+        if (isNullOrUndefined(rowId))
+            rowId = '0';
+        let items = this.getItemListValues(controlId, rowId);
+        let value = this.task.getFormControl(rowId, controlId).value;
+        if (value !== null && value !== "" && items instanceof Array) {
+            value = value.toLowerCase();
+            return items.filter(option => option.displayValue.toLowerCase().includes(value));
+        }
+        else
+            return items;
+    }
     getDisplayValue(id, rowId) {
         let displayValue = "";
         let o = this.getProperty(id, HtmlProperties.ItemsList, rowId);
@@ -3029,12 +2384,6 @@ class AccessorMagicService {
             displayValue = o[value].displayValue;
         return displayValue;
     }
-    /**
-     * Returns whether a tab page is selected or not
-     * @param  index of current option in iterarotr
-     * @param control Id of list control
-     * @returns
-     */ // isOptionSelected
     isOptionSelected(index, controlId) {
         let val = this.task.getValue(controlId, "0");
         for (let item of val) {
@@ -3043,40 +2392,18 @@ class AccessorMagicService {
         }
         return false;
     }
-    /**
-     * Returns whether a tab page is selected or not - used for the tab buttons
-     * @param controlId Id of control
-     * @param  layer Id of the tab page
-     * @returns
-     */ // mgIsTabPageSelected
     isTabPageSelected(controlId, layer) {
         let val = this.task.getProperty(controlId, HtmlProperties.SelectedValue);
-        return val == (layer - 1); // comparing string to number!
-    }
-    /**
-     * Returns whether a tab page layer is selected or not - used for the div which represents the tab page
-     * @param controlId Id of control
-     * @param  layer Id of the tab page
-     * @returns
-     */ // mgIsTabLayerSelected
+        return val == (layer - 1);
+    }
     isTabPageLayerSelected(controlId, layer) {
         let val = this.task.getProperty(controlId, HtmlProperties.SelectedLayer);
-        return val == (layer - 1); // comparing string to number!
+        return val == (layer - 1);
     }
-    /**
-     * Returns the index of the selected tab page
-     * @param controlId Id of control
-     * @returns
-     */
     getTabSelectedIndex(controlId) {
         let val = this.task.getProperty(controlId, HtmlProperties.SelectedValue);
-        return val; // comparing string to number!
+        return val;
     }
-    // private methodes
-    /**
-     * @ignore
-     */
-    // mgIfRowCreated
     ifRowCreated(row) {
         if (row == null)
             return false;
@@ -3084,48 +2411,25 @@ class AccessorMagicService {
         let result = this.getFormGroupByRow(rowId);
         return !isNullOrUndefined(result);
     }
-    /**
-     * @ignore
-     */
-    // mgGetFormGroupByRow
     getFormGroupByRow(id) {
         return this.task.formGroups[id];
     }
-    /**
-     * @ignore
-     */
-    // isRowSelected (not changed)
     isRowSelected(controlId, rowId) {
         const selectedRow = this.task.getProperty(controlId, HtmlProperties.SelectedRow, "0");
         return selectedRow == rowId;
     }
-    /**
-     * Returns whether a row is in edit state
-     * @param row
-     */
     isRowInRowEditing(row) {
         let guiRowId = '0';
         guiRowId = typeof row == "number" ? row.toString() : row.rowId;
         return this.task.isRowInRowEditing(guiRowId);
     }
-    /**
-     * Returns whether a row is in edit state, use this method while control outside table control
-     * @param row
-     */
     isCurrentInRowEditing() {
         let row = this.task.tableService.getSelectedRow();
         return this.task.isRowInRowEditing(row);
     }
-    /**
-     * @ignore
-     */
-    // GetGuiTopIndex
     guiTopIndex() {
         return this.task.tableService.getTableTopIndex();
     }
-    /**
-     * @ignore
-     */
     getErrMsg(id, rowId) {
         let c = this.task.getFormControl(rowId, id);
         if (c.hasError('required'))
@@ -3147,12 +2451,6 @@ class AccessorMagicService {
         }
         return 'unknown error';
     }
-    /**
-     * Sets a user-supplied value to the specified control
-     * @param controlName
-     * @param value
-     * @param refreshDisplay
-     */
     setValueToControl(controlName, value, refreshDisplay) {
         if (typeof refreshDisplay === "undefined")
             refreshDisplay = true;
@@ -3161,44 +2459,28 @@ class AccessorMagicService {
         guiEvent.param = refreshDisplay;
         this.task.insertEvent(guiEvent);
     }
-    /**
-   * @ignore
-   */
     isDataviewEmpty() {
         return this.task.Records.isEmptyDataView;
     }
-    /**
-     * simulates a click event on the specified control, for the Magic engine
-     * @param controlName
-     * @param rowId
-     */
     simulateClick(controlName, rowId) {
         if (typeof rowId === "undefined")
             rowId = 0;
         this.task.insertEvent(getGuiEventObj('click', controlName, rowId));
     }
-    /**
-     * Return Boolean TRUE if user logged in Else it will return FALSE
-     */
     isLoggedIn() {
         return this.task.getIsLoggenIn();
     }
-    /**
-     * Returns JS object containing the records with all table fields.
-     */
     GetFormRecords() {
         let rowId = 0;
         let recArray;
         if (!isNullOrUndefined(this.task.Records) && this.task.Records.list.length > 0) {
             let recList = this.task.Records.list;
             let tableControls = new Array();
-            //Generate list of table fields names
             for (const key in this.task.template) {
                 if (this.task.template[key] == '1')
                     tableControls.push(key);
             }
             recArray = new Array();
-            //Update the records as list of objects with values for table fields.
             if (tableControls.length > 0) {
                 recList.forEach((ctrlMetaData) => {
                     if (this.task.Records.isRowCreated(rowId)) {
@@ -3214,20 +2496,23 @@ class AccessorMagicService {
         }
         return recArray;
     }
+    SetCookie(name, value, expires, path, domain, secure, sameSite) {
+        CookieService.setCookie(name, value, expires, path, domain, secure, sameSite);
+    }
+    GetCookie(name) {
+        return CookieService.getCookie(name);
+    }
+    DeleteCookie(name) {
+        return CookieService.deleteCookie(name);
+    }
 }
-/** @nocollapse */ AccessorMagicService.ɵfac = function AccessorMagicService_Factory(t) { return new (t || AccessorMagicService)(ɵɵinject(TaskMagicService)); };
-/** @nocollapse */ AccessorMagicService.ɵprov = ɵɵdefineInjectable({ token: AccessorMagicService, factory: AccessorMagicService.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(AccessorMagicService, [{
+AccessorMagicService.ɵfac = function AccessorMagicService_Factory(t) { return new (t || AccessorMagicService)(ɵɵinject(TaskMagicService)); };
+AccessorMagicService.ɵprov = ɵɵdefineInjectable({ token: AccessorMagicService, factory: AccessorMagicService.ɵfac });
+(function () { ɵsetClassMetadata(AccessorMagicService, [{
         type: Injectable
     }], function () { return [{ type: TaskMagicService }]; }, null); })();
 
-/**
- * Central place for adding the Magic services
- */
 class MagicServices {
-    /**
-     * @ignore
-     */
     constructor(task, subformService, tableService, titleService, mgAccessorService) {
         this.task = task;
         this.subformService = subformService;
@@ -3240,74 +2525,36 @@ class MagicServices {
         task.mgAccessorService = mgAccessorService;
     }
 }
-/** @nocollapse */ MagicServices.ɵfac = function MagicServices_Factory(t) { return new (t || MagicServices)(ɵɵinject(TaskMagicService), ɵɵinject(SubformMagicService), ɵɵinject(TableMagicService), ɵɵinject(TitleMagicService), ɵɵinject(AccessorMagicService)); };
-/** @nocollapse */ MagicServices.ɵprov = ɵɵdefineInjectable({ token: MagicServices, factory: MagicServices.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicServices, [{
+MagicServices.ɵfac = function MagicServices_Factory(t) { return new (t || MagicServices)(ɵɵinject(TaskMagicService), ɵɵinject(SubformMagicService), ɵɵinject(TableMagicService), ɵɵinject(TitleMagicService), ɵɵinject(AccessorMagicService)); };
+MagicServices.ɵprov = ɵɵdefineInjectable({ token: MagicServices, factory: MagicServices.ɵfac });
+(function () { ɵsetClassMetadata(MagicServices, [{
         type: Injectable
     }], function () { return [{ type: TaskMagicService }, { type: SubformMagicService }, { type: TableMagicService }, { type: TitleMagicService }, { type: AccessorMagicService }]; }, null); })();
 
-/**
- * Base component representing a Magic task
- */
 class TaskBaseMagicComponent {
-    /**
-     *
-     * @param ref changes-detector object
-     * @param magicServices Access point for all Magic services
-     */
     constructor(ref, magicServices) {
         this.ref = ref;
         this.magicServices = magicServices;
-        /**
-         * @ignore
-         */
         this.magicProperties = MagicProperties;
     }
-    /**
-     * Returns the Magic task service
-     * @returns
-     */
     get task() {
         return this.magicServices.task;
     }
-    /**
-     * Returns the Magic subform service
-     * @returns
-     */
     get mgSub() {
         return this.magicServices.subformService;
     }
-    /**
-     * Returns the Magic table service
-     * @returns
-     */
     get tableService() {
         return this.magicServices.tableService;
     }
-    /**
-     * Returns the Magic accessor service
-     * @returns
-     */
     get mg() {
         return this.magicServices.mgAccessorService;
     }
-    /**
-     * Returns the task Id
-     * @returns
-     */
     get taskId() {
         return this.task.taskId;
     }
-    /**
-     * Returns the FormGroup for screen-mode forms
-     * @returns
-     */
     get screenFormGroup() {
         return this.task.ScreenModeControls;
     }
-    /**
-     * Interface implementation
-     */
     ngOnInit() {
         let subscription = this.task.detectChanges.pipe().subscribe(c => {
             this.ref.detectChanges();
@@ -3315,48 +2562,19 @@ class TaskBaseMagicComponent {
         this.task.initTask(this.taskIdParam, this.taskDescription);
         this.createFormControlsAccessor(this.screenFormGroup);
         this.setInputDateFormat();
-        // subcribe to custom property changes
         this.task.customPropertiesSubject.pipe().subscribe(property => {
             this.PropertyChanged(property.propertyName, property.rowId, property.value);
         });
-        // subcribe to records count changes
         this.task.recordsCountChangeSubject.pipe().subscribe(value => {
             this.RecordsCountChanged(value);
         });
     }
-    /**
-     * @ignore
-     */
     createFormControlsAccessor(formGroup) { }
-    /**
-     * @ignore
-     */
     setInputDateFormat() { }
-    /**
-     * This method is called when the value of any custom property is updated in Magic
-     * propertyName : name of property which is updated. The format is <controlname>~<propertyname>
-     * rowId : row number of the updated property for controls in table control (0 for controls outside table)
-     * value : updated value of the property
-     * @returns : void
-     * To use the method override it in your component and check the property name and write you code ..for eg
-     * if(propertyName == 'controlname~propertyName') {// your code}
-     *  else { // your code}
-     */
     PropertyChanged(propertyName, rowId, value) {
-        // intentionally left blank because the implementation should be in the derived class
-    }
-    /**
-     * Records count change subject is subscribed to change in its value. This method will be called
-     * as the value of records count is received at from server.
-     * @returns : void
-     * To use the method override it in your component.
-     */
+    }
     RecordsCountChanged(recordsCount) {
-        // intentionally left blank because the implementation should be in the derived class
     }
-    /**
-     * Interface implementation
-     */
     ngAfterViewInit() {
         this.mgSub.init();
     }
@@ -3366,16 +2584,13 @@ class TaskBaseMagicComponent {
             this.task.oldPageSize = this.tableService.getPageSize();
         }
     }
-    /**
-     * Interface implementation
-     */
     ngOnDestroy() {
         this.task.dispose();
     }
 }
-/** @nocollapse */ TaskBaseMagicComponent.ɵfac = function TaskBaseMagicComponent_Factory(t) { return new (t || TaskBaseMagicComponent)(ɵɵdirectiveInject(ChangeDetectorRef), ɵɵdirectiveInject(MagicServices)); };
-/** @nocollapse */ TaskBaseMagicComponent.ɵcmp = ɵɵdefineComponent({ type: TaskBaseMagicComponent, selectors: [["task-magic"]], inputs: { taskIdParam: "taskIdParam", taskDescription: "taskDescription" }, features: [ɵɵProvidersFeature([TaskMagicService, SubformMagicService, TableMagicService])], decls: 0, vars: 0, template: function TaskBaseMagicComponent_Template(rf, ctx) { }, encapsulation: 2 });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(TaskBaseMagicComponent, [{
+TaskBaseMagicComponent.ɵfac = function TaskBaseMagicComponent_Factory(t) { return new (t || TaskBaseMagicComponent)(ɵɵdirectiveInject(ChangeDetectorRef), ɵɵdirectiveInject(MagicServices)); };
+TaskBaseMagicComponent.ɵcmp = ɵɵdefineComponent({ type: TaskBaseMagicComponent, selectors: [["task-magic"]], inputs: { taskIdParam: "taskIdParam", taskDescription: "taskDescription" }, features: [ɵɵProvidersFeature([TaskMagicService, SubformMagicService, TableMagicService])], decls: 0, vars: 0, template: function TaskBaseMagicComponent_Template(rf, ctx) { }, encapsulation: 2 });
+(function () { ɵsetClassMetadata(TaskBaseMagicComponent, [{
         type: Component,
         args: [{
                 selector: 'task-magic',
@@ -3388,22 +2603,13 @@ class TaskBaseMagicComponent {
             type: Input
         }] }); })();
 
-/**
- * @ignore
- */
 class RowMagicDirective {
     constructor(_task, element) {
         this._task = _task;
         this.element = element;
-        /**
-         * @ignore
-         */
         this.rowChangedSubscriber = null;
         this.htmlElement = this.element.nativeElement;
     }
-    /**
-     * Initializes this object
-     */
     ngOnInit() {
         this.rowChangedSubscriber = this._task
             .OnSelectedRowChanged.pipe(filter(rowId => rowId === this.rowId))
@@ -3418,16 +2624,7 @@ class RowMagicDirective {
         return (rect.top >= parentRect.top &&
             rect.bottom <= parentRect.bottom);
     }
-    /**
-     * Cleanup
-     */
     ngOnDestroy() {
-        // Don't know why, but when the table is loaded for the first time, we
-        // get ngOnInit() for the 1st row (rowId = "0") and then ngOnDestroy()
-        // for number of rows in the page but here this.rowId is undefined.
-        // Since ngOnInit() was not called for all these rows, this.rowChangedSubscriber
-        // is null and hence crashes.
-        // So, the condition to check nulity is added.
         if (this.rowChangedSubscriber !== null) {
             this.rowChangedSubscriber.unsubscribe();
         }
@@ -3435,15 +2632,16 @@ class RowMagicDirective {
     onClick($event) {
         if (this.rowId != '') {
             this._task.insertEvent(getGuiEventObj('click', "magicRow", +this.rowId));
-            event.cancelBubble = true;
+            if (MagicDirective.noOfAutoCompleteBoxesOpened < 1)
+                event.cancelBubble = true;
         }
     }
 }
-/** @nocollapse */ RowMagicDirective.ɵfac = function RowMagicDirective_Factory(t) { return new (t || RowMagicDirective)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ElementRef)); };
-/** @nocollapse */ RowMagicDirective.ɵdir = ɵɵdefineDirective({ type: RowMagicDirective, selectors: [["", "magicRow", ""]], hostBindings: function RowMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
+RowMagicDirective.ɵfac = function RowMagicDirective_Factory(t) { return new (t || RowMagicDirective)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ElementRef)); };
+RowMagicDirective.ɵdir = ɵɵdefineDirective({ type: RowMagicDirective, selectors: [["", "magicRow", ""]], hostBindings: function RowMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
         ɵɵlistener("click", function RowMagicDirective_click_HostBindingHandler($event) { return ctx.onClick($event); });
     } }, inputs: { rowId: ["magicRow", "rowId"] } });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(RowMagicDirective, [{
+(function () { ɵsetClassMetadata(RowMagicDirective, [{
         type: Directive,
         args: [{
                 selector: '[magicRow]'
@@ -3456,35 +2654,16 @@ class RowMagicDirective {
             args: ['click', ['$event']]
         }] }); })();
 
-/**
- * Connects HTML elements to the Magic Web Client engine
- */
 class MagicDirective {
-    /**
-     *
-     * @param _task The task service
-     * @param element The element for which the directive is applied
-     * @param renderer Renderer for the element
-     * @param vcRef
-     * @param magicRow
-     */
     constructor(_task, element, renderer, vcRef, magicRow) {
         this._task = _task;
         this.element = element;
         this.renderer = renderer;
         this.vcRef = vcRef;
         this.magicRow = magicRow;
-        /**
-         * Collection of event handlers for this element
-         */
         this.eventHandlers = {};
         this.eventsOnlyVal = false;
         this.htmlElement = this.element.nativeElement;
-        //let c = (<any>this.vcRef)._view;
-        //while (!(c instanceof TaskBaseMagicComponent)) {
-        //  c = c.component;
-        //}
-        //this.component = c;
         if (!(typeof magicRow === 'undefined' || magicRow === null))
             this.rowId = magicRow.rowId;
     }
@@ -3493,40 +2672,28 @@ class MagicDirective {
         this.selector = 'magic';
     }
     ;
-    /**
-     * This flag is used when we only want to register to events, but do not want to execute commands sent from server
-     */
     set eventsOnly(val) {
         console.log('eventsOnly');
         this.eventsOnlyVal = true;
     }
     ;
-    /**
-     * Get the task service
-     * @returns
-     */
     get task() {
         return this._task;
     }
-    /**
-     * Register to the events this element may need to handle
-     */
     regEvents() {
-        // Handle events for which event handler may be removed and restored
         this.eventHandlers['focusin'] = this.OnFocus.bind(this);
         Object.keys(this.eventHandlers).forEach((key) => {
             this.focusUnlistener = this.renderer.listen(this.htmlElement, key, this.eventHandlers[key]);
         });
-        // Handle events with anonymous  event handlers
-        let events = ['click', 'mousedown', 'dblclick']; // ,'resize', 'load', 'unload'
+        let events = ['click', 'mousedown', 'dblclick'];
         events.forEach(event => {
             this.renderer.listen(this.htmlElement, event, (e) => {
-                // check if the event is fired from zoom button ( to identify the connected zoom button in engine)
                 let fromButton = false;
                 if (this.htmlElement instanceof HTMLButtonElement)
                     fromButton = true;
                 this.task.insertEvent(getGuiEventObj(event, this.id, +this.rowId, fromButton));
-                e.cancelBubble = true;
+                if (MagicDirective.noOfAutoCompleteBoxesOpened < 1)
+                    e.cancelBubble = true;
             });
         });
         this.renderer.listen(this.htmlElement, 'change', (e) => {
@@ -3537,13 +2704,10 @@ class MagicDirective {
                 this.task.insertEvent(guiEvent);
             }
         });
-        // handle the input event
         fromEvent(this.htmlElement, 'input').pipe(map((event) => {
             return event.target.value;
-        }), debounceTime(200) // time after which value will be sent to magic
-        ).subscribe((x) => {
+        }), debounceTime(200)).subscribe((x) => {
             if (this.task.getProperty(this.id, HtmlProperties.BindingLevel, this.rowId) === BindingLevel.Character) {
-                // Don't support character binding for date/time values
                 let attribute = this.task.Records.list[0].getControlMetadata(this.id).dataType;
                 if (attribute !== StorageAttributeType.Date && attribute != StorageAttributeType.Time)
                     this.task.mgAccessorService.setValueToControl(this.id, x, true);
@@ -3569,25 +2733,16 @@ class MagicDirective {
                 (e.keyCode >= GuiConstants.KEY_F1 && e.keyCode <= GuiConstants.KEY_F12);
             if (guiEvent.modifiers !== Modifiers.MODIFIER_NONE || supportedKey) {
                 guiEvent.keyCode = e.keyCode;
-                // Defect 160021 fixed - don't set e.cancelBubble when combobox is opened and esc key is pressed
-                if (e.keyCode !== GuiConstants.KEY_ESC || e.keyCode === GuiConstants.KEY_ESC && !MagicDirective.opened)
+                if (e.keyCode !== GuiConstants.KEY_ESC || e.keyCode === GuiConstants.KEY_ESC && (!MagicDirective.opened && MagicDirective.noOfAutoCompleteBoxesOpened < 1))
                     e.cancelBubble = true;
                 this.task.insertEvent(guiEvent);
             }
         });
     }
-    /**
-     * Handle focus event
-     */
     OnFocus() {
         this.task.insertEvent(getGuiEventObj('focus', this.id, +this.rowId));
         event.cancelBubble = true;
     }
-    /**
-     * Is the command's element the same as this directive's element
-     * @param command
-     * @returns true/false
-     */
     IsSameElement(command) {
         let line = command.line;
         if (this.task.isTableControl(command.CtrlName))
@@ -3596,17 +2751,9 @@ class MagicDirective {
             (line === +this.rowId ||
                 (line === 0 && isNullOrUndefined(this.rowId))));
     }
-    /**
-     * Is the command's element the same as this directive's component
-     * @param command
-     * @returns true/false
-     */
     IsSameComponent(command) {
         return (command.controlName === this.id);
     }
-    /**
-     * @ignore
-     */
     regUpdatesUI() {
         this.subscribeRefreshDom = this.task
             .refreshDom.pipe(filter(c => this.IsSameElement(c)))
@@ -3628,17 +2775,10 @@ class MagicDirective {
             this.handleInteractiveCommands(command);
         });
     }
-    /**
-     * Initializes this object
-     */
     ngOnInit() {
         this.regEvents();
         this.regUpdatesUI();
     }
-    /**
-     * Handles the commands received from the Magic WebClient engine
-     * @param command
-     */
     handleCommand(command) {
         switch (command.CommandType) {
             case CommandType.SET_PROPERTY:
@@ -3646,16 +2786,12 @@ class MagicDirective {
                 break;
             case CommandType.SET_FOCUS:
                 this.focusUnlistener();
-                // Do not set focus on connected zoom  button
                 if (!(command.obj.ConnectedControl && this.htmlElement instanceof HTMLButtonElement))
                     this.htmlElement.focus();
                 this.focusUnlistener = this.renderer.listen(this.htmlElement, 'focusin', this.eventHandlers['focusin']);
                 break;
         }
     }
-    /**
-     * handle the interactive commands like CallJS
-     */
     handleInteractiveCommands(command) {
         switch (command._commandType) {
             case InteractiveCommandType.CALL_JS:
@@ -3665,24 +2801,18 @@ class MagicDirective {
                 let resultString = '';
                 try {
                     if (!isNullOrUndefined(magicComponent[methodName])) {
-                        // invoke the method on instance of magic componenet
                         resultString = magicComponent[methodName].apply(magicComponent, args);
                     }
                     else
-                        console.error('Instance method ' + methodName + ' does not exists'); // when method is not found
+                        console.error('Instance method ' + methodName + ' does not exists');
                 }
                 catch (e) {
-                    // any other exception
                     console.error(e.message);
                 }
-                command.resultString = resultString; // update the return value
+                command.resultString = resultString;
                 break;
         }
     }
-    /**
-     * Handle the Magic set-property command
-     * @param command
-     */
     handleSetProperty(command) {
         switch (command.Operation) {
             case HtmlProperties.ReadOnly:
@@ -3693,17 +2823,15 @@ class MagicDirective {
                 break;
         }
     }
-    /**
-     * Cleanup
-     */
     ngOnDestroy() {
         this.subscribeRefreshDom.unsubscribe();
     }
 }
 MagicDirective.opened = false;
-/** @nocollapse */ MagicDirective.ɵfac = function MagicDirective_Factory(t) { return new (t || MagicDirective)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(ViewContainerRef), ɵɵdirectiveInject(RowMagicDirective, 8)); };
-/** @nocollapse */ MagicDirective.ɵdir = ɵɵdefineDirective({ type: MagicDirective, selectors: [["", "magic", ""]], inputs: { magic: "magic", eventsOnly: "eventsOnly", rowId: "rowId" } });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicDirective, [{
+MagicDirective.noOfAutoCompleteBoxesOpened = 0;
+MagicDirective.ɵfac = function MagicDirective_Factory(t) { return new (t || MagicDirective)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(ViewContainerRef), ɵɵdirectiveInject(RowMagicDirective, 8)); };
+MagicDirective.ɵdir = ɵɵdefineDirective({ type: MagicDirective, selectors: [["", "magic", ""]], inputs: { magic: "magic", eventsOnly: "eventsOnly", rowId: "rowId" } });
+(function () { ɵsetClassMetadata(MagicDirective, [{
         type: Directive,
         args: [{
                 selector: '[magic]'
@@ -3720,9 +2848,6 @@ MagicDirective.opened = false;
             type: Input
         }] }); })();
 
-/**
- * @ignore
- */
 class NoControlMagicDirective extends MagicDirective {
     constructor(_task, element, renderer, vcRef, magicRow) {
         super(_task, element, renderer, vcRef, magicRow);
@@ -3757,12 +2882,10 @@ class NoControlMagicDirective extends MagicDirective {
             }
         }
     }
-    // is the div a tab control
     isTabControl() {
         return this.htmlElement instanceof HTMLDivElement &&
             this.htmlElement.children[0].getAttribute('magicMark') === "magicTabControl";
     }
-    // is the div a radio buttons wrapper
     isRadio() {
         return this.htmlElement instanceof HTMLDivElement &&
             this.htmlElement.children[0].getAttribute('magicMark') === "magicRadio";
@@ -3771,7 +2894,6 @@ class NoControlMagicDirective extends MagicDirective {
         super.handleCommand(command);
         switch (command.CommandType) {
             case CommandType.SET_CLASS:
-                //remove the class which was replaced by this new one, as registered in the ControlMetadata
                 const controlMetadata = this._task.Records.list[0].getControlMetadata(this.id);
                 if (controlMetadata.removedClass != '') {
                     this.htmlElement.classList.remove(controlMetadata.removedClass);
@@ -3784,7 +2906,7 @@ class NoControlMagicDirective extends MagicDirective {
                     this.htmlElement.innerText = command.value;
                 if (this.htmlElement instanceof HTMLSelectElement)
                     this.htmlElement.value = command.value;
-                if (this.htmlElement instanceof HTMLAnchorElement) //hyper-text button
+                if (this.htmlElement instanceof HTMLAnchorElement)
                     this.htmlElement.text = command.value;
                 if (this.htmlElement instanceof HTMLInputElement) {
                     if (this.htmlElement.type === "checkbox") {
@@ -3808,7 +2930,6 @@ class NoControlMagicDirective extends MagicDirective {
                 break;
         }
     }
-    // handle set-property commands
     handleSetProperty(command) {
         super.handleSetProperty(command);
         switch (command.Operation) {
@@ -3824,7 +2945,6 @@ class NoControlMagicDirective extends MagicDirective {
                 break;
             case HtmlProperties.ItemsList:
                 if (this.htmlElement instanceof HTMLSelectElement) {
-                    // clear the list
                     var len = this.htmlElement.length;
                     for (var i = len - 1; i >= 0; i--) {
                         this.htmlElement.remove(i);
@@ -3866,8 +2986,7 @@ class NoControlMagicDirective extends MagicDirective {
                         let child = tabControl.children[i];
                         const layer = child.getAttribute('layer') - 1;
                         if (child instanceof HTMLButtonElement) {
-                            // set button style
-                            if (layer == command.obj1) { // compare int to string
+                            if (layer == command.obj1) {
                                 child.classList.add('tab_button_active');
                             }
                             else {
@@ -3875,7 +2994,6 @@ class NoControlMagicDirective extends MagicDirective {
                             }
                         }
                         else {
-                            // not a buton - hide unselected tabpages
                             let style = (layer == command.obj1) ? 'display: inline' : 'display: none';
                             child.setAttribute('style', style);
                         }
@@ -3897,9 +3015,9 @@ class NoControlMagicDirective extends MagicDirective {
         }
     }
 }
-/** @nocollapse */ NoControlMagicDirective.ɵfac = function NoControlMagicDirective_Factory(t) { return new (t || NoControlMagicDirective)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(ViewContainerRef), ɵɵdirectiveInject(RowMagicDirective, 8)); };
-/** @nocollapse */ NoControlMagicDirective.ɵdir = ɵɵdefineDirective({ type: NoControlMagicDirective, selectors: [["", "magicnc", ""]], inputs: { magic: ["magicnc", "magic"] }, features: [ɵɵInheritDefinitionFeature] });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(NoControlMagicDirective, [{
+NoControlMagicDirective.ɵfac = function NoControlMagicDirective_Factory(t) { return new (t || NoControlMagicDirective)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(ViewContainerRef), ɵɵdirectiveInject(RowMagicDirective, 8)); };
+NoControlMagicDirective.ɵdir = ɵɵdefineDirective({ type: NoControlMagicDirective, selectors: [["", "magicnc", ""]], inputs: { magic: ["magicnc", "magic"] }, features: [ɵɵInheritDefinitionFeature] });
+(function () { ɵsetClassMetadata(NoControlMagicDirective, [{
         type: Directive,
         args: [{
                 selector: '[magicnc]'
@@ -3911,127 +3029,9 @@ class NoControlMagicDirective extends MagicDirective {
             args: ['magicnc']
         }] }); })();
 
-/**
- * Mock component, implements routing by connecting the requested URL with the appropriate Magic task
- */
-class RouterContainerMagicComponent {
-    /**
-     *
-     * @param changeDetectorRef
-     * @param activatedRoute
-     * @param magic
-     * @param componentFactoryResolver
-     * @param viewContainerRef
-     * @param componentList
-     * @param pendingCommandsCollector
-     */
-    constructor(activatedRoute, magic, containerTaskService, componentFactoryResolver, viewContainerRef, componentList, pendingCommandsCollector, routerCommandsMagicService) {
-        this.activatedRoute = activatedRoute;
-        this.magic = magic;
-        this.containerTaskService = containerTaskService;
-        this.componentFactoryResolver = componentFactoryResolver;
-        this.viewContainerRef = viewContainerRef;
-        this.componentList = componentList;
-        this.pendingCommandsCollector = pendingCommandsCollector;
-        this.routerCommandsMagicService = routerCommandsMagicService;
-        this.componentRef = null;
-        this.parentMgSubformService = null;
-    }
-    /**
-     * Initialization
-     */
-    ngOnInit() {
-        let outletname = this.activatedRoute.outlet;
-        let subformMagicService = SubformMagicService.currentCallerMgSubformServiceRef;
-        let currentActiveRoute = SubformMagicService.getRelativeRoute(this.activatedRoute);
-        if (subformMagicService == null || subformMagicService.currentRouteDefinition === null) {
-            this.insertRouteEvent(currentActiveRoute);
-            SubformMagicService.routerContainers.push(this);
-        }
-        else {
-            this.initializeComponent();
-        }
-    }
-    insertRouteEvent(currentActiveRoute) {
-        let guiEvent = getGuiEventObj('RouterNavigate', null, 0);
-        guiEvent.RouterPath = currentActiveRoute.snapshot.routeConfig.path;
-        if (currentActiveRoute.snapshot.outlet !== 'primary')
-            guiEvent.RouterOutletName = currentActiveRoute.snapshot.outlet;
-        // if this is LoadOnDemandModuleMagicComponent it's mean that this is load on demand module and we
-        // need to take the path form routeConfig.path
-        let calcRouterPath = currentActiveRoute.routeConfig.path;
-        // add the RouterPath only if exist
-        if (calcRouterPath.length > 0) {
-            let routerPath = calcRouterPath;
-            let tokens = StrUtil.tokenize(routerPath, "/:");
-            guiEvent.RouterPath = tokens[0];
-            guiEvent.RouterParams = new List();
-            for (let i = 1; i < tokens.length; i++) {
-                guiEvent.RouterParams.push(this.activatedRoute.snapshot.params[tokens[i]]);
-            }
-        }
-        this.containerTaskService.insertEvent(guiEvent);
-    }
-    initializeComponent() {
-        // re-init subformMagicService  since it may change after executing "RouterNavigate" event.
-        let subformMagicService = SubformMagicService.currentCallerMgSubformServiceRef;
-        if (subformMagicService.currentRouteDefinition !== null) {
-            let comp = this.componentList.getComponent(subformMagicService.currentRouteDefinition.formName);
-            const componentFactory = this.componentFactoryResolver.resolveComponentFactory(comp);
-            this.componentRef = this.viewContainerRef.createComponent(componentFactory);
-            Object.assign(this.componentRef.instance, subformMagicService.currentRouteDefinition.parameters);
-            let myActiveRoute = SubformMagicService.getRelativeRoute(this.activatedRoute);
-            let routeParams = StrUtil.tokenize(myActiveRoute.snapshot.routeConfig.path, "/:");
-            subformMagicService.routesDict[myActiveRoute.snapshot.outlet] = routeParams[0];
-            this.parentMgSubformService = subformMagicService;
-            subformMagicService.currentRouteDefinition = null;
-            SubformMagicService.currentCallerMgSubformServiceRef = null;
-            //When the component is initialized, then also we get the notification for paramMap subscription.
-            //But in this case,  we do not have to raise the event, because magic engine itself has  initiated the route with the same parameters.
-            //So, control it via ignoreParamChange flag.
-            let ignoreParamChange = true;
-            myActiveRoute.paramMap.subscribe(params => {
-                if (!ignoreParamChange)
-                    this.insertRouteEvent(myActiveRoute);
-                ignoreParamChange = false;
-            });
-            this.parentMgSubformService.refreshView();
-            this.routerCommandsMagicService.ExecuteNextCommand();
-        }
-    }
-    /**
-     * Cleanup
-     */
-    ngOnDestroy() {
-        // TODO Routing: Call close() only if the task is not already closed.
-        // Task can be closed when a router is overlayed by another task via call operation.
-        if (this.componentRef != null) {
-            this.componentRef.instance.task.close();
-            let currentActiveRoute = SubformMagicService.getRelativeRoute(this.activatedRoute);
-            this.parentMgSubformService.routesDict[currentActiveRoute.outlet] = "";
-        }
-    }
-}
-/** @nocollapse */ RouterContainerMagicComponent.ɵfac = function RouterContainerMagicComponent_Factory(t) { return new (t || RouterContainerMagicComponent)(ɵɵdirectiveInject(ActivatedRoute), ɵɵdirectiveInject(EngineMagicService), ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ComponentFactoryResolver), ɵɵdirectiveInject(ViewContainerRef), ɵɵdirectiveInject(ComponentListMagicService), ɵɵdirectiveInject(CommandsCollectorMagicService), ɵɵdirectiveInject(RouterCommandsMagicService)); };
-/** @nocollapse */ RouterContainerMagicComponent.ɵcmp = ɵɵdefineComponent({ type: RouterContainerMagicComponent, selectors: [["magic-route-outlet"]], decls: 0, vars: 0, template: function RouterContainerMagicComponent_Template(rf, ctx) { }, encapsulation: 2 });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(RouterContainerMagicComponent, [{
-        type: Component,
-        args: [{
-                selector: 'magic-route-outlet',
-                template: `
-  `
-            }]
-    }], function () { return [{ type: ActivatedRoute }, { type: EngineMagicService }, { type: TaskMagicService }, { type: ComponentFactoryResolver }, { type: ViewContainerRef }, { type: ComponentListMagicService }, { type: CommandsCollectorMagicService }, { type: RouterCommandsMagicService }]; }, null); })();
-
-/**
- * @ignore
- */
 class Constants {
 }
 Constants.DATE_FMT = 'dd/MMM/yyyy';
-/**
- * @ignore
- */
 class DateMagicPipe extends DatePipe {
     constructor(_task) {
         super('en-US');
@@ -4043,7 +3043,6 @@ class DateMagicPipe extends DatePipe {
         let mgDateFormatter = new MgDateFormatter();
         if (!isNullOrUndefined(value) && mask !== null) {
             formatStr = mgDateFormatter.ConvertMgDateFormatToAngular(mask);
-            // If control is label control of table, due to query mode, then save the format here.
             if (formatStr != null && this._task.isTableControl(controlId)) {
                 if (this._task.mgInputDateFormat == null)
                     this._task.mgInputDateFormat = formatStr;
@@ -4057,9 +3056,9 @@ class DateMagicPipe extends DatePipe {
         return value;
     }
 }
-/** @nocollapse */ DateMagicPipe.ɵfac = function DateMagicPipe_Factory(t) { return new (t || DateMagicPipe)(ɵɵdirectiveInject(TaskMagicService)); };
-/** @nocollapse */ DateMagicPipe.ɵpipe = ɵɵdefinePipe({ name: "magicDate", type: DateMagicPipe, pure: true });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(DateMagicPipe, [{
+DateMagicPipe.ɵfac = function DateMagicPipe_Factory(t) { return new (t || DateMagicPipe)(ɵɵdirectiveInject(TaskMagicService)); };
+DateMagicPipe.ɵpipe = ɵɵdefinePipe({ name: "magicDate", type: DateMagicPipe, pure: true });
+(function () { ɵsetClassMetadata(DateMagicPipe, [{
         type: Pipe,
         args: [{
                 name: 'magicDate'
@@ -4124,17 +3123,11 @@ class MgDateFormatter {
             return formatStr.ToString();
         }
         else
-            return "dd-mm-yyyy"; // return default format.
+            return "dd-mm-yyyy";
     }
 }
 
-/**
- * Perform Magic validation on input controls which hold alphanumeric strings
- */
 class MgformatMagicDirective {
-    /**
-     * @ignore
-     */
     constructor(magicDir, _task) {
         this.magicDir = magicDir;
         this._task = _task;
@@ -4142,20 +3135,12 @@ class MgformatMagicDirective {
     ngAfterViewInit() {
         let control = this._task.getFormControl(this.magicDir.rowId, this.magicDir.id);
         if (control != null && this._task.mgInputDateFormat == null) {
-            // get the first date control's format.
             let pic = this._task.GetControlPictureMask(this.magicDir.id);
             if (pic.getAttr() == StorageAttribute.DATE) {
                 this.formatDate(pic);
             }
         }
     }
-    /**
-     * @ignore
-     */
-    /**
-     * This can be used to set pattern
-     * On input, verifies the input matches the required mask
-     */
     onFocusEvent($event) {
         let control = this._task.getFormControl(this.magicDir.rowId, this.magicDir.id);
         if (control != null) {
@@ -4180,10 +3165,6 @@ class MgformatMagicDirective {
             }
         }
     }
-    /**
-     * @ignore
-    */
-    // This can be used to implement uppercase/lower case
     onChangeEvent($event) {
         let control = this._task.getFormControl(this.magicDir.rowId, this.magicDir.id);
         let attr = this._task.Records.list[0].getControlMetadata(this.magicDir.id).dataType;
@@ -4201,9 +3182,6 @@ class MgformatMagicDirective {
         let mgDateFormatter = new MgDateFormatter();
         this._task.mgInputDateFormat = mgDateFormatter.ConvertMgDateFormatToAngular(pic.getMask());
     }
-    /**
-     * @ignore
-     */
     formatAlphaUnicode(control) {
         let value = control.value;
         if (value !== null && value.length > 0) {
@@ -4229,9 +3207,6 @@ class MgformatMagicDirective {
             control.setValue(valueStr.ToString());
         }
     }
-    /**
-     * @ignore
-     */
     formatBoolean(control) {
         let value = control.value;
         if (value !== null && value.length > 0) {
@@ -4244,12 +3219,6 @@ class MgformatMagicDirective {
             }
         }
     }
-    /**
-     * @ignore
-     */
-    /// <summary>
-    /// generate pattern from  fld's  format
-    /// </summary>
     generatePattern(attribute, pic) {
         let pattern = "";
         switch (attribute) {
@@ -4263,12 +3232,6 @@ class MgformatMagicDirective {
         }
         return pattern;
     }
-    /**
-     * @ignore
-     */
-    /// <summary>
-    /// generate pattern for Alpha
-    /// </summary>
     generatePatternForNumber(pic) {
         let patternStr = new StringBuilder();
         patternStr.Append("^");
@@ -4281,9 +3244,6 @@ class MgformatMagicDirective {
         patternStr.Append("$");
         return patternStr.ToString();
     }
-    /**
-     * @ignore
-     */
     isPatternGenerationNeeded(attr, pic) {
         switch (attr) {
             case StorageAttribute.NUMERIC:
@@ -4293,12 +3253,6 @@ class MgformatMagicDirective {
                 return (pic.getMaskChars() > 0) ? true : false;
         }
     }
-    /**
-     * @ignore
-     */
-    /// <summary>
-    /// generate pattern for Alpha
-    /// </summary>
     generatePatternForAlpha(pic) {
         let cnt = 0;
         let inputAllChars = false;
@@ -4309,7 +3263,6 @@ class MgformatMagicDirective {
         let pattern = new StringBuilder();
         pattern.Append("^");
         for (let i = 0; i < mask.length;) {
-            //start new subset , if mask[i] is one of these.
             if (inputAllChars && (mask.charCodeAt(i) == PICInterface.PIC_N || mask.charCodeAt(i) == PICInterface.PIC_U || mask.charCodeAt(i) == PICInterface.PIC_L
                 || mask.charCodeAt(i) == PICInterface.PIC_X)) {
                 pattern.Append("(");
@@ -4355,13 +3308,9 @@ class MgformatMagicDirective {
         pattern.Append("$");
         return pattern.ToString();
     }
-    /**
-     * @ignore
-     */
     getDirectiveCount(mask, idx, pattern, changeInPattern) {
         changeInPattern.value = false;
         let patternCount = 0;
-        // find max chars
         while (idx < mask.length && this.IsPatternMatches(mask.charCodeAt(idx).toString(), pattern)) {
             patternCount++;
             idx++;
@@ -4370,9 +3319,6 @@ class MgformatMagicDirective {
             changeInPattern.value = true;
         return patternCount;
     }
-    /**
-     * @ignore
-     */
     IsPatternMatches(mask, pattern) {
         for (let i = 0; i < pattern.length; i++)
             if (mask == pattern[i])
@@ -4380,11 +3326,11 @@ class MgformatMagicDirective {
         return false;
     }
 }
-/** @nocollapse */ MgformatMagicDirective.ɵfac = function MgformatMagicDirective_Factory(t) { return new (t || MgformatMagicDirective)(ɵɵdirectiveInject(MagicDirective), ɵɵdirectiveInject(TaskMagicService)); };
-/** @nocollapse */ MgformatMagicDirective.ɵdir = ɵɵdefineDirective({ type: MgformatMagicDirective, selectors: [["", "mgFormat", ""]], hostBindings: function MgformatMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
+MgformatMagicDirective.ɵfac = function MgformatMagicDirective_Factory(t) { return new (t || MgformatMagicDirective)(ɵɵdirectiveInject(MagicDirective), ɵɵdirectiveInject(TaskMagicService)); };
+MgformatMagicDirective.ɵdir = ɵɵdefineDirective({ type: MgformatMagicDirective, selectors: [["", "mgFormat", ""]], hostBindings: function MgformatMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
         ɵɵlistener("focus", function MgformatMagicDirective_focus_HostBindingHandler($event) { return ctx.onFocusEvent($event); })("change", function MgformatMagicDirective_change_HostBindingHandler($event) { return ctx.onChangeEvent($event); });
     } } });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MgformatMagicDirective, [{
+(function () { ɵsetClassMetadata(MgformatMagicDirective, [{
         type: Directive,
         args: [{
                 selector: '[mgFormat]'
@@ -4397,9 +3343,6 @@ class MgformatMagicDirective {
             args: ['change', ['$event']]
         }] }); })();
 
-/**
- * @ignore
- */
 class TimeMagicPipe extends DatePipe {
     constructor(_task) {
         super('en-US');
@@ -4435,33 +3378,20 @@ class TimeMagicPipe extends DatePipe {
         return value;
     }
 }
-/** @nocollapse */ TimeMagicPipe.ɵfac = function TimeMagicPipe_Factory(t) { return new (t || TimeMagicPipe)(ɵɵdirectiveInject(TaskMagicService)); };
-/** @nocollapse */ TimeMagicPipe.ɵpipe = ɵɵdefinePipe({ name: "magicTime", type: TimeMagicPipe, pure: true });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(TimeMagicPipe, [{
+TimeMagicPipe.ɵfac = function TimeMagicPipe_Factory(t) { return new (t || TimeMagicPipe)(ɵɵdirectiveInject(TaskMagicService)); };
+TimeMagicPipe.ɵpipe = ɵɵdefinePipe({ name: "magicTime", type: TimeMagicPipe, pure: true });
+(function () { ɵsetClassMetadata(TimeMagicPipe, [{
         type: Pipe,
         args: [{
                 name: 'magicTime'
             }]
     }], function () { return [{ type: TaskMagicService }]; }, null); })();
 
-/**
- * Validates the field range.
- */
 class RangeValidatorMagicDirective {
-    /**
-     *
-     * @param _task The task service
-     * @param vcRef
-     */
     constructor(_task, vcRef) {
         this._task = _task;
         this.vcRef = vcRef;
     }
-    /**
-     * Validation method
-     * @param c FormControl to validate
-     * @returns If validation fails, return error message, else returns null
-     */
     validate(c) {
         let controlName;
         controlName = this.getControlName(c);
@@ -4483,23 +3413,20 @@ class RangeValidatorMagicDirective {
             };
         }
     }
-    /**
-     * @ignore
-     */
     getControlName(c) {
         const formGroup = c.parent.controls;
         return Object.keys(formGroup).find(name => c === formGroup[name]) || null;
     }
 }
-/** @nocollapse */ RangeValidatorMagicDirective.ɵfac = function RangeValidatorMagicDirective_Factory(t) { return new (t || RangeValidatorMagicDirective)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ViewContainerRef)); };
-/** @nocollapse */ RangeValidatorMagicDirective.ɵdir = ɵɵdefineDirective({ type: RangeValidatorMagicDirective, selectors: [["", "rangevalidator", ""]], features: [ɵɵProvidersFeature([
+RangeValidatorMagicDirective.ɵfac = function RangeValidatorMagicDirective_Factory(t) { return new (t || RangeValidatorMagicDirective)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ViewContainerRef)); };
+RangeValidatorMagicDirective.ɵdir = ɵɵdefineDirective({ type: RangeValidatorMagicDirective, selectors: [["", "rangevalidator", ""]], features: [ɵɵProvidersFeature([
             {
                 provide: NG_VALIDATORS,
                 useExisting: RangeValidatorMagicDirective,
                 multi: true,
             }
         ])] });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(RangeValidatorMagicDirective, [{
+(function () { ɵsetClassMetadata(RangeValidatorMagicDirective, [{
         type: Directive,
         args: [{
                 selector: '[rangevalidator] ',
@@ -4519,48 +3446,29 @@ function SubformMagicComponent_ndc_dynamic_0_Template(rf, ctx) { if (rf & 1) {
     const ctx_r0 = ɵɵnextContext();
     ɵɵproperty("ndcDynamicComponent", ctx_r0.Component)("ndcDynamicInputs", ctx_r0.Parameters);
 } }
-/**
- * Represents a Magic subform
- */
 class SubformMagicComponent {
-    /**
-     * @ignore
-     */
     constructor(vcRef, mgSub) {
         this.vcRef = vcRef;
         this.mgSub = mgSub;
-        /**
-         * @ignore
-         */
         this.component = null;
-        // For angular 10 - find the component from views
         this.component = (this.vcRef._hostView).find(v => !isNullOrUndefined(v));
     }
-    /**
-     * @ignore
-     */
     set magic(val) { this.id = val; }
     ;
-    /**
-     * @ignore
-     */
     get Component() {
         return this.mgSub.mgGetComp(this.id);
     }
-    /**
-     * @ignore
-     */
     get Parameters() {
         return this.mgSub.mgGetParameters(this.id);
     }
 }
-/** @nocollapse */ SubformMagicComponent.ɵfac = function SubformMagicComponent_Factory(t) { return new (t || SubformMagicComponent)(ɵɵdirectiveInject(ViewContainerRef), ɵɵdirectiveInject(SubformMagicService)); };
-/** @nocollapse */ SubformMagicComponent.ɵcmp = ɵɵdefineComponent({ type: SubformMagicComponent, selectors: [["magic-subform"]], inputs: { magic: "magic" }, decls: 1, vars: 1, consts: [[3, "ndcDynamicComponent", "ndcDynamicInputs", 4, "ngIf"], [3, "ndcDynamicComponent", "ndcDynamicInputs"]], template: function SubformMagicComponent_Template(rf, ctx) { if (rf & 1) {
+SubformMagicComponent.ɵfac = function SubformMagicComponent_Factory(t) { return new (t || SubformMagicComponent)(ɵɵdirectiveInject(ViewContainerRef), ɵɵdirectiveInject(SubformMagicService)); };
+SubformMagicComponent.ɵcmp = ɵɵdefineComponent({ type: SubformMagicComponent, selectors: [["magic-subform"]], inputs: { magic: "magic" }, decls: 1, vars: 1, consts: [[3, "ndcDynamicComponent", "ndcDynamicInputs", 4, "ngIf"], [3, "ndcDynamicComponent", "ndcDynamicInputs"]], template: function SubformMagicComponent_Template(rf, ctx) { if (rf & 1) {
         ɵɵtemplate(0, SubformMagicComponent_ndc_dynamic_0_Template, 1, 2, "ndc-dynamic", 0);
     } if (rf & 2) {
         ɵɵproperty("ngIf", ctx.Component);
     } }, directives: [NgIf, DynamicComponent, DynamicIoDirective], encapsulation: 2 });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(SubformMagicComponent, [{
+(function () { ɵsetClassMetadata(SubformMagicComponent, [{
         type: Component,
         args: [{
                 selector: 'magic-subform',
@@ -4600,24 +3508,14 @@ function ErrorMagicComponent_div_0_Template(rf, ctx) { if (rf & 1) {
     ɵɵproperty("ngIf", ctx_r0.defaultDisplay);
 } }
 const _c1$1 = ["*"];
-/**
- * Represents a Magic subform
- */
 class ErrorMagicComponent {
-    /**
-     * @ignore
-     */
     constructor(_task, mgService, changeDetectorRef) {
         this._task = _task;
         this.mgService = mgService;
         this.changeDetectorRef = changeDetectorRef;
-        // if true - display standard magic error message, if false - customer has provides his own content and we'll use it
         this.defaultDisplay = true;
         this.rowId = "0";
     }
-    /**
-     * @ignore
-     */
     set magic(val) {
         this.id = val;
     }
@@ -4631,10 +3529,6 @@ class ErrorMagicComponent {
         this.changeDetectorRef.detectChanges();
     }
     ;
-    /**
-     * returns true if the html element has no children
-     * @param element
-     */
     isEmpty(element) {
         const nodes = element.childNodes;
         for (let i = 0; i < nodes.length; i++) {
@@ -4645,9 +3539,6 @@ class ErrorMagicComponent {
         }
         return true;
     }
-    /**
-     * @ignore
-     */
     HasErrors(id) {
         if (!isUndefined(id)) {
             let control = this._task.getFormControl(this.rowId, id);
@@ -4669,8 +3560,8 @@ class ErrorMagicComponent {
         return false;
     }
 }
-/** @nocollapse */ ErrorMagicComponent.ɵfac = function ErrorMagicComponent_Factory(t) { return new (t || ErrorMagicComponent)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(AccessorMagicService), ɵɵdirectiveInject(ChangeDetectorRef)); };
-/** @nocollapse */ ErrorMagicComponent.ɵcmp = ɵɵdefineComponent({ type: ErrorMagicComponent, selectors: [["mgError"]], viewQuery: function ErrorMagicComponent_Query(rf, ctx) { if (rf & 1) {
+ErrorMagicComponent.ɵfac = function ErrorMagicComponent_Factory(t) { return new (t || ErrorMagicComponent)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(AccessorMagicService), ɵɵdirectiveInject(ChangeDetectorRef)); };
+ErrorMagicComponent.ɵcmp = ɵɵdefineComponent({ type: ErrorMagicComponent, selectors: [["mgError"]], viewQuery: function ErrorMagicComponent_Query(rf, ctx) { if (rf & 1) {
         ɵɵviewQuery(_c0$2, true);
     } if (rf & 2) {
         var _t;
@@ -4681,7 +3572,7 @@ class ErrorMagicComponent {
     } if (rf & 2) {
         ɵɵproperty("ngIf", ctx.HasErrors(ctx.id));
     } }, directives: [NgIf], encapsulation: 2 });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(ErrorMagicComponent, [{
+(function () { ɵsetClassMetadata(ErrorMagicComponent, [{
         type: Component,
         args: [{
                 selector: 'mgError',
@@ -4706,28 +3597,19 @@ class ErrorMagicComponent {
             args: ['customContent', { static: false }]
         }] }); })();
 
-/**
- * Directive for checkboxes, to handle the 'change' event
- */
 class CheckboxMagicDirective {
-    /**
-     * @ignore
-     */
     constructor(magicDirective) {
         this.magicDirective = magicDirective;
     }
-    /**
-     * Handles the Checkbox 'change' event - pass it to the Magic engine
-     */
     onChange($event) {
         this.magicDirective.task.onCheckChanged($event, this.magicDirective.id, +this.magicDirective.rowId);
     }
 }
-/** @nocollapse */ CheckboxMagicDirective.ɵfac = function CheckboxMagicDirective_Factory(t) { return new (t || CheckboxMagicDirective)(ɵɵdirectiveInject(MagicDirective)); };
-/** @nocollapse */ CheckboxMagicDirective.ɵdir = ɵɵdefineDirective({ type: CheckboxMagicDirective, selectors: [["input", "type", "checkbox", "magic", "", 3, "noFormControl", ""]], hostBindings: function CheckboxMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
+CheckboxMagicDirective.ɵfac = function CheckboxMagicDirective_Factory(t) { return new (t || CheckboxMagicDirective)(ɵɵdirectiveInject(MagicDirective)); };
+CheckboxMagicDirective.ɵdir = ɵɵdefineDirective({ type: CheckboxMagicDirective, selectors: [["input", "type", "checkbox", "magic", "", 3, "noFormControl", ""]], hostBindings: function CheckboxMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
         ɵɵlistener("change", function CheckboxMagicDirective_change_HostBindingHandler($event) { return ctx.onChange($event); });
     } } });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(CheckboxMagicDirective, [{
+(function () { ɵsetClassMetadata(CheckboxMagicDirective, [{
         type: Directive,
         args: [{
                 selector: `
@@ -4739,25 +3621,19 @@ class CheckboxMagicDirective {
             args: ['change', ['$event']]
         }] }); })();
 
-/**
- * Directive for comboboxes, to handle the 'change' event
- */
 class ComboboxMagicDirective {
     constructor(magicDirective) {
         this.magicDirective = magicDirective;
     }
-    /**
-     * Handles the Combobox 'change' event - pass it to the Magic engine
-     */
     onChange($event) {
         this.magicDirective.task.onComboboxSelectionChanged($event, this.magicDirective.id, +this.magicDirective.rowId);
     }
 }
-/** @nocollapse */ ComboboxMagicDirective.ɵfac = function ComboboxMagicDirective_Factory(t) { return new (t || ComboboxMagicDirective)(ɵɵdirectiveInject(MagicDirective)); };
-/** @nocollapse */ ComboboxMagicDirective.ɵdir = ɵɵdefineDirective({ type: ComboboxMagicDirective, selectors: [["select", "magic", "", 3, "multiple", ""]], hostBindings: function ComboboxMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
+ComboboxMagicDirective.ɵfac = function ComboboxMagicDirective_Factory(t) { return new (t || ComboboxMagicDirective)(ɵɵdirectiveInject(MagicDirective)); };
+ComboboxMagicDirective.ɵdir = ɵɵdefineDirective({ type: ComboboxMagicDirective, selectors: [["select", "magic", "", 3, "multiple", ""]], hostBindings: function ComboboxMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
         ɵɵlistener("change", function ComboboxMagicDirective_change_HostBindingHandler($event) { return ctx.onChange($event); });
     } } });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(ComboboxMagicDirective, [{
+(function () { ɵsetClassMetadata(ComboboxMagicDirective, [{
         type: Directive,
         args: [{
                 selector: `select[magic]:not([multiple])`,
@@ -4767,20 +3643,14 @@ class ComboboxMagicDirective {
             args: ['change', ['$event']]
         }] }); })();
 
-/**
- * This service supports custom actions on magic exit
- */
 class ExitMagicService {
-    /**
-     * Override this method to implement custom logic on magic exit
-     */
     exitMagic() {
         console.log("Magic application terminated");
     }
 }
-/** @nocollapse */ ExitMagicService.ɵfac = function ExitMagicService_Factory(t) { return new (t || ExitMagicService)(); };
-/** @nocollapse */ ExitMagicService.ɵprov = ɵɵdefineInjectable({ token: ExitMagicService, factory: ExitMagicService.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(ExitMagicService, [{
+ExitMagicService.ɵfac = function ExitMagicService_Factory(t) { return new (t || ExitMagicService)(); };
+ExitMagicService.ɵprov = ɵɵdefineInjectable({ token: ExitMagicService, factory: ExitMagicService.ɵfac });
+(function () { ɵsetClassMetadata(ExitMagicService, [{
         type: Injectable
     }], null, null); })();
 
@@ -4804,19 +3674,7 @@ function MagicShellComponent_div_5_Template(rf, ctx) { if (rf & 1) {
 function MagicShellComponent_ng_template_6_Template(rf, ctx) { if (rf & 1) {
     ɵɵelement(0, "div", 9);
 } }
-/**
- * Root Magic component
- */
 class MagicShellComponent {
-    /**
-     *
-     * @param magic Magic's service
-     * @param componentList Magic component list
-     * @param changeDetectorRef Changes detector
-     * @param titleService Title setting service
-     * @param httpClient The native httpClient instance
-     * @param exitMagicService Magic exit service
-     */
     constructor(engineMagicService, componentList, changeDetectorRef, titleService, overlayWindowService, httpClient, pendingCommandsCollector, exitMagicService) {
         this.engineMagicService = engineMagicService;
         this.componentList = componentList;
@@ -4826,32 +3684,22 @@ class MagicShellComponent {
         this.httpClient = httpClient;
         this.pendingCommandsCollector = pendingCommandsCollector;
         this.exitMagicService = exitMagicService;
-        /**
-         * Root component to be displayed in the window
-         */
         this.RootComponent = null;
         this.magicEngineTerminated = false;
         this.initialize();
         this.setTitle();
     }
-    /**
-     * Before-unload event listener
-     * @param event
-     */
     onBeforeUnload(event) {
         if (this.engineMagicService.TransCacheExists()) {
-            // Show the confirmation box before unloading the browser
             event.returnValue = 'Are you sure?';
             return 'Are you sure?';
         }
         else {
-            // terminate the magic server context using fetch API with keep-alive
             this.engineMagicService.TerminateContextUsingFetchAPI();
             this.magicEngineTerminated = true;
         }
     }
     onUnload(event) {
-        // Chrome provides an opportunity to terminate the context after user approves the browser unload alert
         if (!this.magicEngineTerminated)
             this.engineMagicService.TerminateContextUsingFetchAPI();
     }
@@ -4862,26 +3710,13 @@ class MagicShellComponent {
     setViewContainerRef(vcRef) {
         this.overlayWindowsContainerViewRef = vcRef;
     }
-    /**
-     * Initialization of Magic mechanisms
-     */
     initialize() {
         this.registerUICommands();
     }
-    /**
-     * Set the title
-     */
     setTitle() {
         const newTitle = this.componentList.title;
         this.titleService.setTitle(newTitle);
     }
-    /**
-     * Set the component according to requested form
-     * @param formName Name of the form to open
-     * @param taskId Id of opening task
-     * @param taskDescription TODO
-     * @param isModal whether modal window is being opened
-     */
     setComponent(formName, taskId, taskDescription, isModal) {
         this.pendingCommandsCollector.startCollecting();
         if (isModal) {
@@ -4893,9 +3728,6 @@ class MagicShellComponent {
         }
         this.changeDetectorRef.detectChanges();
     }
-    /**
-     * @ignore
-     */
     registerUICommands() {
         this.engineMagicService.refreshDom.pipe(filter(command => command.TaskTag === '0'))
             .subscribe(command => {
@@ -4907,10 +3739,6 @@ class MagicShellComponent {
             GuiInteractiveExecutor.executeInteractiveCommand(null, command, this.overlayWindowService);
         });
     }
-    /**
-     * Execute commands received from the Magic WebClient engine
-     * @param command
-     */
     executeCommand(command) {
         switch (command.CommandType) {
             case CommandType.OPEN_FORM:
@@ -4925,7 +3753,7 @@ class MagicShellComponent {
                     this.RootComponentParameters = {};
                     this.changeDetectorRef.detectChanges();
                 }
-                else { // Close modal window
+                else {
                     this.overlayWindowService.close(command.str);
                     this.changeDetectorRef.detectChanges();
                 }
@@ -4943,20 +3771,21 @@ class MagicShellComponent {
                 if (this.exitMagicService)
                     this.exitMagicService.exitMagic();
                 break;
+            case CommandType.SHOW_HTML_ERROR:
+                window.document.write(command.str);
+                break;
         }
     }
 }
-/** @nocollapse */ MagicShellComponent.ɵfac = function MagicShellComponent_Factory(t) { return new (t || MagicShellComponent)(ɵɵdirectiveInject(EngineMagicService), ɵɵdirectiveInject(ComponentListMagicService), ɵɵdirectiveInject(ChangeDetectorRef), ɵɵdirectiveInject(Title), ɵɵdirectiveInject(OverlayWindowService), ɵɵdirectiveInject(HttpClient), ɵɵdirectiveInject(CommandsCollectorMagicService), ɵɵdirectiveInject(ExitMagicService, 8)); };
-/** @nocollapse */ MagicShellComponent.ɵcmp = ɵɵdefineComponent({ type: MagicShellComponent, selectors: [["magic-root"]], viewQuery: function MagicShellComponent_Query(rf, ctx) { if (rf & 1) {
+MagicShellComponent.ɵfac = function MagicShellComponent_Factory(t) { return new (t || MagicShellComponent)(ɵɵdirectiveInject(EngineMagicService), ɵɵdirectiveInject(ComponentListMagicService), ɵɵdirectiveInject(ChangeDetectorRef), ɵɵdirectiveInject(Title), ɵɵdirectiveInject(OverlayWindowService), ɵɵdirectiveInject(HttpClient), ɵɵdirectiveInject(CommandsCollectorMagicService), ɵɵdirectiveInject(ExitMagicService, 8)); };
+MagicShellComponent.ɵcmp = ɵɵdefineComponent({ type: MagicShellComponent, selectors: [["magic-root"]], viewQuery: function MagicShellComponent_Query(rf, ctx) { if (rf & 1) {
         ɵɵstaticViewQuery(_c0$3, true);
     } if (rf & 2) {
         var _t;
         ɵɵqueryRefresh(_t = ɵɵloadQuery()) && (ctx.rootMagicElementRef = _t.first);
     } }, hostBindings: function MagicShellComponent_HostBindings(rf, ctx) { if (rf & 1) {
         ɵɵlistener("beforeunload", function MagicShellComponent_beforeunload_HostBindingHandler($event) { return ctx.onBeforeUnload($event); }, false, ɵɵresolveWindow)("unload", function MagicShellComponent_unload_HostBindingHandler($event) { return ctx.onUnload($event); }, false, ɵɵresolveWindow);
-    } }, inputs: { SpinnerTemplate: "SpinnerTemplate" }, features: [ɵɵProvidersFeature([
-        // ExitMagicService
-        ])], decls: 8, vars: 2, consts: [["magicRoot", ""], [3, "ndcDynamicComponent", "ndcDynamicInputs", 4, "ngIf"], ["magicViewContainerRef", ""], ["overlayWindowsContainer", ""], ["class", "spinner-background", 4, "ngIf"], ["defaultSpinner", ""], [3, "ndcDynamicComponent", "ndcDynamicInputs"], [1, "spinner-background"], [3, "ngTemplateOutlet"], [1, "mgSpinnerClass"]], template: function MagicShellComponent_Template(rf, ctx) { if (rf & 1) {
+    } }, inputs: { SpinnerTemplate: "SpinnerTemplate" }, features: [ɵɵProvidersFeature([])], decls: 8, vars: 2, consts: [["magicRoot", ""], [3, "ndcDynamicComponent", "ndcDynamicInputs", 4, "ngIf"], ["magicViewContainerRef", ""], ["overlayWindowsContainer", ""], ["class", "spinner-background", 4, "ngIf"], ["defaultSpinner", ""], [3, "ndcDynamicComponent", "ndcDynamicInputs"], [1, "spinner-background"], [3, "ngTemplateOutlet"], [1, "mgSpinnerClass"]], template: function MagicShellComponent_Template(rf, ctx) { if (rf & 1) {
         ɵɵelementStart(0, "div", null, 0);
         ɵɵtemplate(2, MagicShellComponent_ndc_dynamic_2_Template, 1, 2, "ndc-dynamic", 1);
         ɵɵelement(3, "div", 2, 3);
@@ -4969,13 +3798,11 @@ class MagicShellComponent {
         ɵɵadvance(3);
         ɵɵproperty("ngIf", ctx.showSpinner);
     } }, directives: [NgIf, MagicViewContainerRef, DynamicComponent, DynamicIoDirective, NgTemplateOutlet], styles: [".mgSpinnerClass[_ngcontent-%COMP%] {\n      border: 10px solid #cccccc; \n      border-top: 10px solid black; \n      border-radius: 50%;\n      position: fixed;\n      margin: auto;\n      top: 0;\n      right: 0;\n      bottom: 0;\n      left: 0;\n      width: 100px;\n      height: 100px;\n      animation: spin 2s linear infinite;\n    }\n    .spinner-background[_ngcontent-%COMP%] {\n      \n      position: fixed;\n      top: 0;\n      right: 0;\n      bottom: 0;\n      z-index: 1000;\n      left: 0;\n      opacity: 0.5;\n    }\n    @keyframes spin {\n      0% { transform: rotate(0deg); }\n      100% { transform: rotate(360deg); }\n    }"] });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicShellComponent, [{
+(function () { ɵsetClassMetadata(MagicShellComponent, [{
         type: Component,
         args: [{
                 selector: 'magic-root',
-                providers: [
-                // ExitMagicService
-                ],
+                providers: [],
                 template: `
     <div #magicRoot>
       <ndc-dynamic
@@ -5042,25 +3869,19 @@ class MagicShellComponent {
             args: ['window:unload', ['$event']]
         }] }); })();
 
-/**
- * @ignore
- */
 const CHECKBOX_VALUE_ACCESSOR = {
     provide: NG_VALUE_ACCESSOR,
     useExisting: forwardRef(() => MagicCheckboxControlValueAccessor),
     multi: true,
 };
-/**
- * Value accessor for Checkbox without a FormControl
- */
 class MagicCheckboxControlValueAccessor extends CheckboxControlValueAccessor {
 }
-/** @nocollapse */ MagicCheckboxControlValueAccessor.ɵfac = function MagicCheckboxControlValueAccessor_Factory(t) { return ɵMagicCheckboxControlValueAccessor_BaseFactory(t || MagicCheckboxControlValueAccessor); };
-/** @nocollapse */ MagicCheckboxControlValueAccessor.ɵdir = ɵɵdefineDirective({ type: MagicCheckboxControlValueAccessor, selectors: [["input", "type", "checkbox", "magic", "", 3, "formControlName", "", 3, "no-form-control", ""], ["input", "type", "checkbox", "magic", "", 3, "formControl", ""], ["input", "type", "checkbox", "magic", "", 3, "ngModel", ""]], hostBindings: function MagicCheckboxControlValueAccessor_HostBindings(rf, ctx) { if (rf & 1) {
+MagicCheckboxControlValueAccessor.ɵfac = function MagicCheckboxControlValueAccessor_Factory(t) { return ɵMagicCheckboxControlValueAccessor_BaseFactory(t || MagicCheckboxControlValueAccessor); };
+MagicCheckboxControlValueAccessor.ɵdir = ɵɵdefineDirective({ type: MagicCheckboxControlValueAccessor, selectors: [["input", "type", "checkbox", "magic", "", 3, "formControlName", "", 3, "no-form-control", ""], ["input", "type", "checkbox", "magic", "", 3, "formControl", ""], ["input", "type", "checkbox", "magic", "", 3, "ngModel", ""]], hostBindings: function MagicCheckboxControlValueAccessor_HostBindings(rf, ctx) { if (rf & 1) {
         ɵɵlistener("change", function MagicCheckboxControlValueAccessor_change_HostBindingHandler($event) { return ctx.onChange($event.target.checked); })("blur", function MagicCheckboxControlValueAccessor_blur_HostBindingHandler() { return ctx.onTouched(); });
     } }, features: [ɵɵProvidersFeature([CHECKBOX_VALUE_ACCESSOR]), ɵɵInheritDefinitionFeature] });
-const ɵMagicCheckboxControlValueAccessor_BaseFactory = /*@__PURE__*/ ɵɵgetInheritedFactory(MagicCheckboxControlValueAccessor);
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicCheckboxControlValueAccessor, [{
+const ɵMagicCheckboxControlValueAccessor_BaseFactory = ɵɵgetInheritedFactory(MagicCheckboxControlValueAccessor);
+(function () { ɵsetClassMetadata(MagicCheckboxControlValueAccessor, [{
         type: Directive,
         args: [{
                 selector: `
@@ -5073,25 +3894,19 @@ const ɵMagicCheckboxControlValueAccessor_BaseFactory = /*@__PURE__*/ ɵɵgetInh
             }]
     }], null, null); })();
 
-/**
- * @ignore
- */
 const MAGIC_DEFAULT_VALUE_ACCESSOR = {
     provide: NG_VALUE_ACCESSOR,
     useExisting: forwardRef(() => MagicDefaultValueAccessor),
     multi: true
 };
-/**
- * @ignore
- */
 class MagicDefaultValueAccessor extends DefaultValueAccessor {
 }
-/** @nocollapse */ MagicDefaultValueAccessor.ɵfac = function MagicDefaultValueAccessor_Factory(t) { return ɵMagicDefaultValueAccessor_BaseFactory(t || MagicDefaultValueAccessor); };
-/** @nocollapse */ MagicDefaultValueAccessor.ɵdir = ɵɵdefineDirective({ type: MagicDefaultValueAccessor, selectors: [["input", "magic", "", 3, "type", "checkbox", 3, "formControlName", "", 3, "no-form-control", ""], ["textarea", "magic", "", 3, "formControlName", "", 3, "noFormControl", "", 3, "no-form-control", ""]], hostBindings: function MagicDefaultValueAccessor_HostBindings(rf, ctx) { if (rf & 1) {
+MagicDefaultValueAccessor.ɵfac = function MagicDefaultValueAccessor_Factory(t) { return ɵMagicDefaultValueAccessor_BaseFactory(t || MagicDefaultValueAccessor); };
+MagicDefaultValueAccessor.ɵdir = ɵɵdefineDirective({ type: MagicDefaultValueAccessor, selectors: [["input", "magic", "", 3, "type", "checkbox", 3, "formControlName", "", 3, "no-form-control", ""], ["textarea", "magic", "", 3, "formControlName", "", 3, "noFormControl", "", 3, "no-form-control", ""]], hostBindings: function MagicDefaultValueAccessor_HostBindings(rf, ctx) { if (rf & 1) {
         ɵɵlistener("input", function MagicDefaultValueAccessor_input_HostBindingHandler($event) { return ctx._handleInput($event.target.value); })("blur", function MagicDefaultValueAccessor_blur_HostBindingHandler() { return ctx.onTouched(); })("compositionstart", function MagicDefaultValueAccessor_compositionstart_HostBindingHandler() { return ctx._compositionStart(); })("compositionend", function MagicDefaultValueAccessor_compositionend_HostBindingHandler($event) { return ctx._compositionEnd($event.target.value); });
     } }, exportAs: ["magic"], features: [ɵɵProvidersFeature([MAGIC_DEFAULT_VALUE_ACCESSOR]), ɵɵInheritDefinitionFeature] });
-const ɵMagicDefaultValueAccessor_BaseFactory = /*@__PURE__*/ ɵɵgetInheritedFactory(MagicDefaultValueAccessor);
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicDefaultValueAccessor, [{
+const ɵMagicDefaultValueAccessor_BaseFactory = ɵɵgetInheritedFactory(MagicDefaultValueAccessor);
+(function () { ɵsetClassMetadata(MagicDefaultValueAccessor, [{
         type: Directive,
         args: [{
                 selector: `
@@ -5109,25 +3924,19 @@ const ɵMagicDefaultValueAccessor_BaseFactory = /*@__PURE__*/ ɵɵgetInheritedFa
             }]
     }], null, null); })();
 
-/**
- * Directive for checkboxes which should not have a form control
- */
 class CheckboxNoFormControlMagicDirective {
     constructor(magicDirective) {
         this.magicDirective = magicDirective;
     }
-    /**
-     * Handle the 'Checkbox' change event - pass it to the Magic engine
-     */
     onChange($event) {
         this.magicDirective.task.onCheckChanged($event, this.magicDirective.id, +this.magicDirective.rowId);
     }
 }
-/** @nocollapse */ CheckboxNoFormControlMagicDirective.ɵfac = function CheckboxNoFormControlMagicDirective_Factory(t) { return new (t || CheckboxNoFormControlMagicDirective)(ɵɵdirectiveInject(MagicDirective)); };
-/** @nocollapse */ CheckboxNoFormControlMagicDirective.ɵdir = ɵɵdefineDirective({ type: CheckboxNoFormControlMagicDirective, selectors: [["input", "type", "checkbox", "magic", "", "noFormControl", ""]], hostBindings: function CheckboxNoFormControlMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
+CheckboxNoFormControlMagicDirective.ɵfac = function CheckboxNoFormControlMagicDirective_Factory(t) { return new (t || CheckboxNoFormControlMagicDirective)(ɵɵdirectiveInject(MagicDirective)); };
+CheckboxNoFormControlMagicDirective.ɵdir = ɵɵdefineDirective({ type: CheckboxNoFormControlMagicDirective, selectors: [["input", "type", "checkbox", "magic", "", "noFormControl", ""]], hostBindings: function CheckboxNoFormControlMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
         ɵɵlistener("change", function CheckboxNoFormControlMagicDirective_change_HostBindingHandler($event) { return ctx.onChange($event); });
     } } });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(CheckboxNoFormControlMagicDirective, [{
+(function () { ɵsetClassMetadata(CheckboxNoFormControlMagicDirective, [{
         type: Directive,
         args: [{
                 selector: `
@@ -5139,25 +3948,19 @@ class CheckboxNoFormControlMagicDirective {
             args: ['change', ['$event']]
         }] }); })();
 
-/**
- * Directive for non-checkbox input controls which do not have a form control
- */
 class InputNoFormControlMagicDirective {
     constructor(magicDirective) {
         this.magicDirective = magicDirective;
     }
-    /**
-     * Handles the 'change' event - pass it to the Magic engine
-     */
     onChange($event) {
         this.magicDirective.task.setInputTextValue(this.magicDirective.id, this.magicDirective.rowId, event.srcElement.value);
     }
 }
-/** @nocollapse */ InputNoFormControlMagicDirective.ɵfac = function InputNoFormControlMagicDirective_Factory(t) { return new (t || InputNoFormControlMagicDirective)(ɵɵdirectiveInject(MagicDirective)); };
-/** @nocollapse */ InputNoFormControlMagicDirective.ɵdir = ɵɵdefineDirective({ type: InputNoFormControlMagicDirective, selectors: [["input", "magic", "", "noFormControl", "", 3, "type", "checkbox"], ["textarea", "magic", "", "noFormControl", "", 3, "type", "checkbox"]], hostBindings: function InputNoFormControlMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
+InputNoFormControlMagicDirective.ɵfac = function InputNoFormControlMagicDirective_Factory(t) { return new (t || InputNoFormControlMagicDirective)(ɵɵdirectiveInject(MagicDirective)); };
+InputNoFormControlMagicDirective.ɵdir = ɵɵdefineDirective({ type: InputNoFormControlMagicDirective, selectors: [["input", "magic", "", "noFormControl", "", 3, "type", "checkbox"], ["textarea", "magic", "", "noFormControl", "", 3, "type", "checkbox"]], hostBindings: function InputNoFormControlMagicDirective_HostBindings(rf, ctx) { if (rf & 1) {
         ɵɵlistener("change", function InputNoFormControlMagicDirective_change_HostBindingHandler($event) { return ctx.onChange($event); });
     } } });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(InputNoFormControlMagicDirective, [{
+(function () { ɵsetClassMetadata(InputNoFormControlMagicDirective, [{
         type: Directive,
         args: [{
                 selector: `input[magic]:([noFormControl]):not([type=checkbox]),
@@ -5173,14 +3976,6 @@ const DATE_VALUE_ACCESSOR = {
     useExisting: forwardRef(() => DateValueAccessor),
     multi: true
 };
-/**
- * The accessor for writing a value and listening to changes on a date input element
- *
- *  ### Example
- *  `<input type="date" name="birthday" ngModel dateInput>`
- *  OR
- *  `<input type="date" formControlName="birthday" dateInput>`
- */
 class DateValueAccessor {
     constructor(renderer, elementRef) {
         this.renderer = renderer;
@@ -5188,7 +3983,6 @@ class DateValueAccessor {
         this.onChange = (_) => { };
         this.onTouched = () => { };
     }
-    /** Writes a new value to the element (model -> view) */
     writeValue(value) {
         if (!value) {
             this.renderer.setProperty(this.elementRef.nativeElement, "value", null);
@@ -5196,26 +3990,23 @@ class DateValueAccessor {
         }
         this.renderer.setProperty(this.elementRef.nativeElement, "valueAsDate", new Date(Date.UTC(value.getFullYear(), value.getMonth(), value.getDate())));
     }
-    /** Registers a callback function, called when value changes (view -> model) */
     registerOnChange(fn) {
         this.onChange = v => fn(v instanceof Date
             ? new Date(v.getUTCFullYear(), v.getUTCMonth(), v.getUTCDate())
             : v);
     }
-    /** Registers a callback function, called when the control is blurred */
     registerOnTouched(fn) {
         this.onTouched = fn;
     }
-    /** Enables or disables the element when the control status changes */
     setDisabledState(isDisabled) {
         this.renderer.setProperty(this.elementRef.nativeElement, "disabled", isDisabled);
     }
 }
-/** @nocollapse */ DateValueAccessor.ɵfac = function DateValueAccessor_Factory(t) { return new (t || DateValueAccessor)(ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(ElementRef)); };
-/** @nocollapse */ DateValueAccessor.ɵdir = ɵɵdefineDirective({ type: DateValueAccessor, selectors: [["", "dateInput", ""]], hostBindings: function DateValueAccessor_HostBindings(rf, ctx) { if (rf & 1) {
+DateValueAccessor.ɵfac = function DateValueAccessor_Factory(t) { return new (t || DateValueAccessor)(ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(ElementRef)); };
+DateValueAccessor.ɵdir = ɵɵdefineDirective({ type: DateValueAccessor, selectors: [["", "dateInput", ""]], hostBindings: function DateValueAccessor_HostBindings(rf, ctx) { if (rf & 1) {
         ɵɵlistener("input", function DateValueAccessor_input_HostBindingHandler($event) { return ctx.onChange($event.target.valueAsDate); })("blur", function DateValueAccessor_blur_HostBindingHandler() { return ctx.onTouched(); });
     } }, features: [ɵɵProvidersFeature([DATE_VALUE_ACCESSOR])] });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(DateValueAccessor, [{
+(function () { ɵsetClassMetadata(DateValueAccessor, [{
         type: Directive,
         args: [{
                 selector: "[dateInput]",
@@ -5229,25 +4020,12 @@ class DateValueAccessor {
             args: ["blur", []]
         }] }); })();
 
-/**
- * Responsible for connecting HTML elements to the Magic WebClient engine showing it is not Magic Control but a Dummy control which is used to notify only receeive focus event for now
- */
 class NonMagicControlDirective {
-    /**
-     *
-     * @param _task The task service
-     * @param element The element for which the directive is applied
-     * @param renderer Renderer for the element
-     * @param vcRef
-     */
     constructor(_task, element, renderer, vcRef) {
         this._task = _task;
         this.element = element;
         this.renderer = renderer;
         this.vcRef = vcRef;
-        /**
-         * Collection of event handlers for this element
-         */
         this.eventHandlers = {};
         this.eventsOnlyVal = false;
         this.htmlElement = this.element.nativeElement;
@@ -5257,40 +4035,26 @@ class NonMagicControlDirective {
         this.selector = 'NonMagicControl';
     }
     ;
-    /**
-     * Get the task service
-     * @returns
-     */
     get task() {
         return this._task;
     }
-    /**
-     * Register to the events this element may need to handle
-     */
     regEvents() {
-        // Handle events for which event handler may be removed and restored
         this.eventHandlers['focusin'] = this.OnFocus.bind(this);
         Object.keys(this.eventHandlers).forEach((key) => {
             this.focusUnlistener = this.renderer.listen(this.htmlElement, key, this.eventHandlers[key]);
         });
     }
-    /**
-     * Handle focus event
-     */
     OnFocus() {
         this.task.insertEvent(getGuiEventObj('focusOnNonMagicControl', "", -1));
         event.cancelBubble = true;
     }
-    /**
-     * Initialize this object
-     */
     ngOnInit() {
         this.regEvents();
     }
 }
-/** @nocollapse */ NonMagicControlDirective.ɵfac = function NonMagicControlDirective_Factory(t) { return new (t || NonMagicControlDirective)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(ViewContainerRef)); };
-/** @nocollapse */ NonMagicControlDirective.ɵdir = ɵɵdefineDirective({ type: NonMagicControlDirective, selectors: [["", "NonMagicControl", ""]], inputs: { magic: ["NonMagicControl", "magic"] } });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(NonMagicControlDirective, [{
+NonMagicControlDirective.ɵfac = function NonMagicControlDirective_Factory(t) { return new (t || NonMagicControlDirective)(ɵɵdirectiveInject(TaskMagicService), ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(ViewContainerRef)); };
+NonMagicControlDirective.ɵdir = ɵɵdefineDirective({ type: NonMagicControlDirective, selectors: [["", "NonMagicControl", ""]], inputs: { magic: ["NonMagicControl", "magic"] } });
+(function () { ɵsetClassMetadata(NonMagicControlDirective, [{
         type: Directive,
         args: [{
                 selector: '[NonMagicControl]'
@@ -5300,9 +4064,6 @@ class NonMagicControlDirective {
             args: ['NonMagicControl']
         }] }); })();
 
-/**
- * @ignore
- */
 const decs = [
     MagicDirective,
     CheckboxMagicDirective,
@@ -5333,9 +4094,6 @@ const decs = [
     MagicFocusDirective,
     MagicViewContainerRef
 ];
-/**
- * @ignore
- */
 class MagicModule {
     static forRoot() {
         return {
@@ -5350,12 +4108,11 @@ class MagicModule {
         };
     }
 }
-/** @nocollapse */ MagicModule.ɵmod = ɵɵdefineNgModule({ type: MagicModule });
-/** @nocollapse */ MagicModule.ɵinj = ɵɵdefineInjector({ factory: function MagicModule_Factory(t) { return new (t || MagicModule)(); }, providers: [ConfirmationComponentsMagicProvider, OverlayContainerMagicProvider], imports: [[
+MagicModule.ɵmod = ɵɵdefineNgModule({ type: MagicModule });
+MagicModule.ɵinj = ɵɵdefineInjector({ factory: function MagicModule_Factory(t) { return new (t || MagicModule)(); }, providers: [ConfirmationComponentsMagicProvider, OverlayContainerMagicProvider], imports: [[
             CommonModule,
             FormsModule,
             ReactiveFormsModule,
-            //ThemeModule,
             RouterModule,
             DynamicModule,
             HttpClientModule
@@ -5390,7 +4147,6 @@ class MagicModule {
         MagicViewContainerRef], imports: [CommonModule,
         FormsModule,
         ReactiveFormsModule,
-        //ThemeModule,
         RouterModule,
         DynamicModule,
         HttpClientModule], exports: [MagicDirective,
@@ -5421,7 +4177,7 @@ class MagicModule {
         NonMagicControlDirective,
         MagicFocusDirective,
         MagicViewContainerRef] }); })();
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MagicModule, [{
+(function () { ɵsetClassMetadata(MagicModule, [{
         type: NgModule,
         args: [{
                 declarations: [...decs],
@@ -5431,12 +4187,10 @@ class MagicModule {
                     CommonModule,
                     FormsModule,
                     ReactiveFormsModule,
-                    //ThemeModule,
                     RouterModule,
                     DynamicModule,
                     HttpClientModule
                 ],
-                //Customizable providers
                 providers: [ConfirmationComponentsMagicProvider, OverlayContainerMagicProvider]
             }]
     }], null, null); })();
@@ -5524,7 +4278,7 @@ class MgDateAdapter extends NativeDateAdapter {
             this.mgdtfmt = this.task.mgInputDateFormat;
         if (displayFormat === 'input') {
             if (this.mgdtfmt == null)
-                this.mgdtfmt = 'M/d/yyyy'; //default format
+                this.mgdtfmt = 'M/d/yyyy';
             return formatDate(date, this.mgdtfmt, this.locale);
         }
         else {
@@ -5532,9 +4286,9 @@ class MgDateAdapter extends NativeDateAdapter {
         }
     }
 }
-/** @nocollapse */ MgDateAdapter.ɵfac = function MgDateAdapter_Factory(t) { return new (t || MgDateAdapter)(ɵɵinject(Platform), ɵɵinject(TaskMagicService)); };
-/** @nocollapse */ MgDateAdapter.ɵprov = ɵɵdefineInjectable({ token: MgDateAdapter, factory: MgDateAdapter.ɵfac });
-/*@__PURE__*/ (function () { ɵsetClassMetadata(MgDateAdapter, [{
+MgDateAdapter.ɵfac = function MgDateAdapter_Factory(t) { return new (t || MgDateAdapter)(ɵɵinject(Platform), ɵɵinject(TaskMagicService)); };
+MgDateAdapter.ɵprov = ɵɵdefineInjectable({ token: MgDateAdapter, factory: MgDateAdapter.ɵfac });
+(function () { ɵsetClassMetadata(MgDateAdapter, [{
         type: Injectable
     }], function () { return [{ type: Platform }, { type: TaskMagicService }]; }, null); })();
 
@@ -5542,9 +4296,6 @@ const matDateProviders = [
     { provide: DateAdapter, useClass: MgDateAdapter },
     { provide: MAT_DATE_FORMATS, useValue: MG_FORMATS }
 ];
-/**
- * Magic service providers
- */
 const basicMagicProviders = [
     MagicServices,
     TaskMagicService,
@@ -5558,18 +4309,7 @@ const magicProviders = [
     TableMagicService
 ];
 
-/**
- * @ignore
- */
-///////////////////////////////////////////////////////////
-// class to hold gui-related helper methods
-///////////////////////////////////////////////////////////
 class utils {
-    ///////////////////////////////////////////////////////////
-    // Add magic child control to the supplied array.
-    // Recursive, and checks children even if they are not magic controls.
-    // Magic controls are controls which have a magic directive attached to them.
-    ///////////////////////////////////////////////////////////
     static addChildren(parent, children, selector) {
         for (var i = 0; i < parent.children.length; i++) {
             if (typeof parent.children[i].attributes[selector] !== "undefined") {
@@ -5578,9 +4318,6 @@ class utils {
             this.addChildren(parent.children[i], children, selector);
         }
     }
-    ///////////////////////////////////////////////////////////
-    // Calculate the distance between the control and the supplied x,y coordinates
-    ///////////////////////////////////////////////////////////
     static getDistance(control, x, y) {
         let left = control.clientLeft, top = control.clientTop;
         let dx, dy;
@@ -5607,9 +4344,6 @@ class utils {
         const ret = (dx * dx + dy * dy);
         return ret;
     }
-    ///////////////////////////////////////////////////////////
-    //
-    ///////////////////////////////////////////////////////////
     static getDimentions(el) {
         let xPos = 0;
         let yPos = 0;
@@ -5617,14 +4351,12 @@ class utils {
         let height = el.height;
         while (el) {
             if (el.tagName == "BODY") {
-                // deal with browser quirks with body/window/document and page scroll
                 let xScroll = el.scrollLeft || document.documentElement.scrollLeft;
                 let yScroll = el.scrollTop || document.documentElement.scrollTop;
                 xPos += (el.offsetLeft - xScroll + el.clientLeft);
                 yPos += (el.offsetTop - yScroll + el.clientTop);
             }
             else {
-                // for all other non-BODY elements
                 xPos += (el.offsetLeft - el.scrollLeft + el.clientLeft);
                 yPos += (el.offsetTop - el.scrollTop + el.clientTop);
             }
@@ -5639,9 +4371,6 @@ class utils {
     }
 }
 
-/**
- * @ignore
- */
 class ModalFormDefinition {
     constructor() {
         this.taskId = "";
@@ -5650,9 +4379,5 @@ class ModalFormDefinition {
     }
 }
 
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { AccessorMagicService, BaseMagicAlertComponent, BaseMagicConfirmComponent, BaseMagicOverlayContainer, CHECKBOX_VALUE_ACCESSOR, CheckboxMagicDirective, CheckboxNoFormControlMagicDirective, ComboboxMagicDirective, CommandsCollectorMagicService, ComponentListMagicService, ConfirmationComponentsMagicProvider, Constants, ControlMetadata, ControlsMetadata, DATE_VALUE_ACCESSOR, DateMagicPipe, DateValueAccessor, EngineMagicService, ErrorMagicComponent, ExitMagicService, GuiInteractiveExecutor, HtmlClasses, InputNoFormControlMagicDirective, MAGIC_DEFAULT_VALUE_ACCESSOR, MG_FORMATS, MagicAlertComponent, MagicCheckboxControlValueAccessor, MagicConfirmationBoxComponent, MagicDefaultValueAccessor, MagicDirective, MagicFocusDirective, MagicModule, MagicOverlayContainer, MagicOverlayContainerWrapper, MagicServices, MagicShellComponent, MagicViewContainerRef, MgDateAdapter, MgDateFormatter, MgformatMagicDirective, ModalFormDefinition, NoControlMagicDirective, NonMagicControlDirective, OverlayContainerMagicProvider, OverlayWindowService, RangeValidatorMagicDirective, Records, RouteCommand, RouterCommandsMagicService, RouterContainerMagicComponent, RowMagicDirective, StylesMapManager, SubformMagicComponent, SubformMagicService, TableMagicService, TaskBaseMagicComponent, TaskMagicService, TimeMagicPipe, TitleMagicService, basicMagicProviders, confirmationBox, magicProviders, matDateProviders, utils };
 //# sourceMappingURL=magic-xpa-angular.js.map