@magic-xpa/angular 4.1100.0-dev4110.25 → 4.1100.0-dev4110.250

package/esm2022/src/ui/magic-root.component.mjs

@@ -0,0 +1,236 @@
+import { ChangeDetectorRef, Component, ElementRef, HostListener, Input, Optional, TemplateRef, ViewChild } from '@angular/core';
+import { CommandType } from '@magic-xpa/gui';
+import { Title } from '@angular/platform-browser';
+import { EngineMagicService } from '../services/engine.magic.service';
+import { ComponentListMagicService } from '../services/component-list.magic.service';
+import { GuiInteractiveExecutor } from './GuiInteractiveExecutor';
+import { filter } from 'rxjs/operators';
+import { ExitMagicService } from '../services/exit.magic.service';
+import { OverlayWindowService } from '../services/OverlayWindowService';
+import { CommandsCollectorMagicService } from '../services/commands-collector.magic.service';
+import { HttpClient } from '@angular/common/http';
+import { ActivatedRoute, NavigationEnd, Router } from "@angular/router";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/engine.magic.service";
+import * as i2 from "../services/component-list.magic.service";
+import * as i3 from "@angular/platform-browser";
+import * as i4 from "../services/OverlayWindowService";
+import * as i5 from "@angular/common/http";
+import * as i6 from "../services/commands-collector.magic.service";
+import * as i7 from "@angular/router";
+import * as i8 from "../services/exit.magic.service";
+import * as i9 from "@angular/common";
+import * as i10 from "ng-dynamic-component";
+import * as i11 from "./directives/magicViewContainerRef.directive";
+const _c0 = ["magicRoot"];
+function MagicShellComponent_ndc_dynamic_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "ndc-dynamic", 6);
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ndcDynamicComponent", ctx_r0.RootComponent)("ndcDynamicInputs", ctx_r0.RootComponentParameters);
+} }
+function MagicShellComponent_div_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 7);
+    i0.ɵɵelementContainer(1, 8);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    const defaultSpinner_r2 = i0.ɵɵreference(7);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngTemplateOutlet", ctx_r0.SpinnerTemplate ? ctx_r0.SpinnerTemplate : defaultSpinner_r2);
+} }
+function MagicShellComponent_ng_template_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "div", 9);
+} }
+export class MagicShellComponent {
+    engineMagicService;
+    componentList;
+    changeDetectorRef;
+    titleService;
+    overlayWindowService;
+    httpClient;
+    pendingCommandsCollector;
+    route;
+    router;
+    exitMagicService;
+    RootComponent = null;
+    RootComponentParameters;
+    overlayWindowsContainerViewRef;
+    rootMagicElementRef;
+    SpinnerTemplate;
+    showSpinner;
+    magicEngineTerminated = false;
+    constructor(engineMagicService, componentList, changeDetectorRef, titleService, overlayWindowService, httpClient, pendingCommandsCollector, route, router, exitMagicService) {
+        this.engineMagicService = engineMagicService;
+        this.componentList = componentList;
+        this.changeDetectorRef = changeDetectorRef;
+        this.titleService = titleService;
+        this.overlayWindowService = overlayWindowService;
+        this.httpClient = httpClient;
+        this.pendingCommandsCollector = pendingCommandsCollector;
+        this.route = route;
+        this.router = router;
+        this.exitMagicService = exitMagicService;
+        this.initialize();
+        this.setTitle();
+    }
+    onBeforeUnload(event) {
+        if (this.engineMagicService.TransCacheExists()) {
+            event.returnValue = 'Are you sure?';
+            return 'Are you sure?';
+        }
+        else {
+            this.engineMagicService.TerminateContextUsingFetchAPI();
+            this.magicEngineTerminated = true;
+        }
+    }
+    onUnload(event) {
+        if (!this.magicEngineTerminated)
+            this.engineMagicService.TerminateContextUsingFetchAPI();
+    }
+    ngAfterViewInit() {
+        this.overlayWindowService.init(this.overlayWindowsContainerViewRef, this.rootMagicElementRef.nativeElement, this.changeDetectorRef);
+        let subscription = this.router.events
+            .pipe(filter(e => e instanceof NavigationEnd))
+            .subscribe(e => {
+            if (this.router.navigated) {
+                const queryParams = this.route.snapshot.queryParams;
+                const queryParamsMap = new Map();
+                for (const key in queryParams) {
+                    if (queryParams.hasOwnProperty(key)) {
+                        queryParamsMap.set(key, queryParams[key].toString());
+                    }
+                }
+                this.engineMagicService.startMagicEngine(this.httpClient, queryParamsMap);
+                subscription.unsubscribe();
+            }
+        });
+    }
+    setViewContainerRef(vcRef) {
+        this.overlayWindowsContainerViewRef = vcRef;
+    }
+    initialize() {
+        this.registerUICommands();
+    }
+    setTitle() {
+        const newTitle = this.componentList.title;
+        this.titleService.setTitle(newTitle);
+    }
+    setComponent(formName, taskId, taskDescription, isModal) {
+        this.pendingCommandsCollector.startCollecting();
+        if (isModal) {
+            this.overlayWindowService.open(formName, taskId, taskDescription);
+        }
+        else {
+            this.RootComponent = this.componentList.getComponent(formName);
+            this.RootComponentParameters = { taskIdParam: taskId, taskDescription: taskDescription };
+        }
+        this.changeDetectorRef.detectChanges();
+    }
+    registerUICommands() {
+        this.engineMagicService.refreshDom.pipe(filter(command => command.TaskTag === '0'))
+            .subscribe(command => {
+            this.executeCommand(command);
+        });
+        this.engineMagicService
+            .interactiveCommands.pipe(filter(command => command.TaskTag === '0'))
+            .subscribe(command => {
+            GuiInteractiveExecutor.executeInteractiveCommand(null, command, this.overlayWindowService);
+        });
+    }
+    executeCommand(command) {
+        switch (command.CommandType) {
+            case CommandType.OPEN_FORM:
+                this.setComponent(command.str, command.stringList[0], command.stringList[1], command.Bool1);
+                break;
+            case CommandType.SET_IS_LOGGED_IN:
+                this.engineMagicService.setIsLoggedIn(command.Bool1);
+                break;
+            case CommandType.CLOSE_FORM:
+                if (this.RootComponent != null && command.str === this.RootComponentParameters.taskIdParam) {
+                    this.RootComponent = null;
+                    this.RootComponentParameters = {};
+                    this.changeDetectorRef.detectChanges();
+                }
+                else {
+                    this.overlayWindowService.close(command.str);
+                    this.changeDetectorRef.detectChanges();
+                }
+                break;
+            case CommandType.RELOAD_PAGE:
+                window.location.reload();
+                break;
+            case CommandType.SHOW_SPINNER:
+                if (this.showSpinner != command.Bool1) {
+                    this.showSpinner = command.Bool1;
+                    this.changeDetectorRef.detectChanges();
+                }
+                break;
+            case CommandType.EXIT_MAGIC:
+                if (this.exitMagicService)
+                    this.exitMagicService.exitMagic();
+                break;
+            case CommandType.SHOW_HTML_ERROR:
+                window.document.write(command.str);
+                break;
+        }
+    }
+    static ɵfac = function MagicShellComponent_Factory(t) { return new (t || MagicShellComponent)(i0.ɵɵdirectiveInject(i1.EngineMagicService), i0.ɵɵdirectiveInject(i2.ComponentListMagicService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i3.Title), i0.ɵɵdirectiveInject(i4.OverlayWindowService), i0.ɵɵdirectiveInject(i5.HttpClient), i0.ɵɵdirectiveInject(i6.CommandsCollectorMagicService), i0.ɵɵdirectiveInject(i7.ActivatedRoute), i0.ɵɵdirectiveInject(i7.Router), i0.ɵɵdirectiveInject(i8.ExitMagicService, 8)); };
+    static ɵcmp = i0.ɵɵdefineComponent({ type: MagicShellComponent, selectors: [["magic-root"]], viewQuery: function MagicShellComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 7);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.rootMagicElementRef = _t.first);
+        } }, hostBindings: function MagicShellComponent_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("beforeunload", function MagicShellComponent_beforeunload_HostBindingHandler($event) { return ctx.onBeforeUnload($event); }, false, i0.ɵɵresolveWindow)("unload", function MagicShellComponent_unload_HostBindingHandler($event) { return ctx.onUnload($event); }, false, i0.ɵɵresolveWindow);
+        } }, inputs: { SpinnerTemplate: "SpinnerTemplate" }, features: [i0.ɵɵProvidersFeature([])], decls: 8, vars: 2, consts: [["magicRoot", ""], ["overlayWindowsContainer", ""], ["defaultSpinner", ""], [3, "ndcDynamicComponent", "ndcDynamicInputs", 4, "ngIf"], ["magicViewContainerRef", ""], ["class", "spinner-background", 4, "ngIf"], [3, "ndcDynamicComponent", "ndcDynamicInputs"], [1, "spinner-background"], [3, "ngTemplateOutlet"], [1, "mgSpinnerClass"]], template: function MagicShellComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", null, 0);
+            i0.ɵɵtemplate(2, MagicShellComponent_ndc_dynamic_2_Template, 1, 2, "ndc-dynamic", 3);
+            i0.ɵɵelement(3, "div", 4, 1);
+            i0.ɵɵelementEnd();
+            i0.ɵɵtemplate(5, MagicShellComponent_div_5_Template, 2, 1, "div", 5)(6, MagicShellComponent_ng_template_6_Template, 1, 0, "ng-template", null, 2, i0.ɵɵtemplateRefExtractor);
+        } if (rf & 2) {
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", ctx.RootComponent !== null);
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngIf", ctx.showSpinner);
+        } }, dependencies: [i9.NgIf, i9.NgTemplateOutlet, i10.DynamicComponent, i10.DynamicIoDirective, i11.MagicViewContainerRef], styles: [".mgSpinnerClass[_ngcontent-%COMP%]{border:10px solid #cccccc;border-top:10px solid black;border-radius:50%;position:fixed;margin:auto;inset:0;width:100px;height:100px;animation:_ngcontent-%COMP%_spin 2s linear infinite}.spinner-background[_ngcontent-%COMP%]{position:fixed;z-index:1000;inset:0;opacity:.5}@keyframes _ngcontent-%COMP%_spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}"] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MagicShellComponent, [{
+        type: Component,
+        args: [{ selector: 'magic-root', providers: [], template: `
+    <div #magicRoot>
+      <ndc-dynamic
+        *ngIf = "RootComponent !== null"
+        [ndcDynamicComponent]="RootComponent"
+        [ndcDynamicInputs]   ="RootComponentParameters">
+      </ndc-dynamic>
+
+      <div #overlayWindowsContainer magicViewContainerRef>
+      </div>
+    </div>
+
+    <div class="spinner-background" *ngIf="showSpinner">
+      <ng-container [ngTemplateOutlet]="SpinnerTemplate ? SpinnerTemplate:defaultSpinner"></ng-container>
+    </div>
+
+    <ng-template #defaultSpinner>
+      <div class="mgSpinnerClass"></div>
+    </ng-template>
+  `, styles: [".mgSpinnerClass{border:10px solid #cccccc;border-top:10px solid black;border-radius:50%;position:fixed;margin:auto;inset:0;width:100px;height:100px;animation:spin 2s linear infinite}.spinner-background{position:fixed;z-index:1000;inset:0;opacity:.5}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}\n"] }]
+    }], () => [{ type: i1.EngineMagicService }, { type: i2.ComponentListMagicService }, { type: i0.ChangeDetectorRef }, { type: i3.Title }, { type: i4.OverlayWindowService }, { type: i5.HttpClient }, { type: i6.CommandsCollectorMagicService }, { type: i7.ActivatedRoute }, { type: i7.Router }, { type: i8.ExitMagicService, decorators: [{
+                type: Optional
+            }] }], { rootMagicElementRef: [{
+            type: ViewChild,
+            args: ['magicRoot', { static: true }]
+        }], SpinnerTemplate: [{
+            type: Input
+        }], onBeforeUnload: [{
+            type: HostListener,
+            args: ['window:beforeunload', ['$event']]
+        }], onUnload: [{
+            type: HostListener,
+            args: ['window:unload', ['$event']]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MagicShellComponent, { className: "MagicShellComponent", filePath: "src\\ui\\magic-root.component.ts", lineNumber: 85 }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"magic-root.component.js","sourceRoot":"","sources":["../../../../../../projects/angular/src/ui/magic-root.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  AfterViewInit,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ElementRef,\r\n  HostListener,\r\n  Input,\r\n  Optional,\r\n  TemplateRef,\r\n  ViewChild,\r\n  ViewContainerRef\r\n} from '@angular/core';\r\nimport { CommandType, GuiCommand } from '@magic-xpa/gui';\r\nimport { Title } from '@angular/platform-browser';\r\nimport { EngineMagicService } from '../services/engine.magic.service';\r\nimport { ComponentListMagicService } from '../services/component-list.magic.service';\r\nimport { GuiInteractiveExecutor } from './GuiInteractiveExecutor';\r\nimport { filter } from 'rxjs/operators';\r\nimport { ExitMagicService } from '../services/exit.magic.service';\r\nimport { OverlayWindowService } from '../services/OverlayWindowService';\r\nimport { IMagicViewContainerRef } from '../..';\r\nimport { CommandsCollectorMagicService } from '../services/commands-collector.magic.service';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport {ActivatedRoute, NavigationEnd, Router} from \"@angular/router\";\r\n\r\n/**\r\n * Root Magic component\r\n */\r\n@Component({\r\n  selector: 'magic-root',\r\n  providers: [\r\n   // ExitMagicService\r\n  ],\r\n  template: `\r\n    <div #magicRoot>\r\n      <ndc-dynamic\r\n        *ngIf = \"RootComponent !== null\"\r\n        [ndcDynamicComponent]=\"RootComponent\"\r\n        [ndcDynamicInputs]   =\"RootComponentParameters\">\r\n      </ndc-dynamic>\r\n\r\n      <div #overlayWindowsContainer magicViewContainerRef>\r\n      </div>\r\n    </div>\r\n\r\n    <div class=\"spinner-background\" *ngIf=\"showSpinner\">\r\n      <ng-container [ngTemplateOutlet]=\"SpinnerTemplate ? SpinnerTemplate:defaultSpinner\"></ng-container>\r\n    </div>\r\n\r\n    <ng-template #defaultSpinner>\r\n      <div class=\"mgSpinnerClass\"></div>\r\n    </ng-template>\r\n  `,\r\n  styles: [`\r\n    .mgSpinnerClass {\r\n      border: 10px solid #cccccc; /* Light grey */\r\n      border-top: 10px solid black; /* Blue */\r\n      border-radius: 50%;\r\n      position: fixed;\r\n      margin: auto;\r\n      top: 0;\r\n      right: 0;\r\n      bottom: 0;\r\n      left: 0;\r\n      width: 100px;\r\n      height: 100px;\r\n      animation: spin 2s linear infinite;\r\n    }\r\n    .spinner-background {\r\n      /* background fixed across whole screen */\r\n      position: fixed;\r\n      top: 0;\r\n      right: 0;\r\n      bottom: 0;\r\n      z-index: 1000;\r\n      left: 0;\r\n      opacity: 0.5;\r\n    }\r\n    @keyframes spin {\r\n      0% { transform: rotate(0deg); }\r\n      100% { transform: rotate(360deg); }\r\n    }\r\n  `]\r\n})\r\nexport class MagicShellComponent implements AfterViewInit, IMagicViewContainerRef {\r\n  /**\r\n   * Root component to be displayed in the window\r\n   */\r\n  RootComponent : Component = null;\r\n  /**\r\n   * parameters for the Root Component\r\n   */\r\n  RootComponentParameters : any;\r\n\r\n  overlayWindowsContainerViewRef: ViewContainerRef;\r\n\r\n  @ViewChild('magicRoot', { static: true }) rootMagicElementRef: ElementRef;\r\n\r\n  @Input() SpinnerTemplate: TemplateRef<any>;\r\n\r\n  showSpinner: boolean;\r\n  magicEngineTerminated: boolean = false;\r\n\r\n  /**\r\n   *\r\n   * @param magic Magic's service\r\n   * @param componentList Magic component list\r\n   * @param changeDetectorRef Changes detector\r\n   * @param titleService Title setting service\r\n   * @param httpClient The native httpClient instance\r\n   * @param exitMagicService Magic exit service\r\n   */\r\n  constructor(protected engineMagicService: EngineMagicService,\r\n              protected componentList:ComponentListMagicService,\r\n              protected changeDetectorRef: ChangeDetectorRef,\r\n              private titleService: Title,\r\n              private overlayWindowService: OverlayWindowService,\r\n              private httpClient: HttpClient,\r\n              private pendingCommandsCollector: CommandsCollectorMagicService,\r\n              private route: ActivatedRoute,\r\n              private router: Router,\r\n              @Optional()  public exitMagicService: ExitMagicService) {\r\n\r\n    this.initialize();\r\n    this.setTitle();\r\n  }\r\n\r\n  /**\r\n   * Before-unload event listener\r\n   * @param event\r\n   */\r\n  @HostListener('window:beforeunload', ['$event'])\r\n  onBeforeUnload(event) {\r\n    if(this.engineMagicService.TransCacheExists())\r\n    {\r\n      // Show the confirmation box before unloading the browser\r\n      event.returnValue = 'Are you sure?';\r\n      return 'Are you sure?';\r\n    }\r\n    else\r\n    {\r\n      // terminate the magic server context using fetch API with keep-alive\r\n      this.engineMagicService.TerminateContextUsingFetchAPI();\r\n      this.magicEngineTerminated = true;\r\n    }\r\n  }\r\n\r\n  @HostListener('window:unload', ['$event'])\r\n  onUnload(event) {\r\n    // Chrome provides an opportunity to terminate the context after user approves the browser unload alert\r\n    if(!this.magicEngineTerminated)\r\n      this.engineMagicService.TerminateContextUsingFetchAPI();\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    this.overlayWindowService.init(this.overlayWindowsContainerViewRef, this.rootMagicElementRef.nativeElement, this.changeDetectorRef);\r\n\r\n    let subscription = this.router.events\r\n      .pipe(filter(e => e instanceof NavigationEnd))\r\n      .subscribe(e => {\r\n        if (this.router.navigated) {\r\n          const queryParams = this.route.snapshot.queryParams;\r\n          const queryParamsMap = new Map<string, string>();\r\n\r\n          // Iterate over the queryParams object and populate the Map\r\n          for (const key in queryParams) {\r\n            if (queryParams.hasOwnProperty(key)) {\r\n              queryParamsMap.set(key, queryParams[key].toString());\r\n            }\r\n          }\r\n\r\n          this.engineMagicService.startMagicEngine(this.httpClient, queryParamsMap);\r\n          subscription.unsubscribe();\r\n        }\r\n      });\r\n  }\r\n\r\n  setViewContainerRef(vcRef: ViewContainerRef){\r\n    this.overlayWindowsContainerViewRef = vcRef;\r\n  }\r\n\r\n  /**\r\n   * Initialization of Magic mechanisms\r\n   */\r\n  initialize() {\r\n    this.registerUICommands();\r\n  }\r\n\r\n  /**\r\n   * Set the title\r\n   */\r\n  public setTitle( ) {\r\n    const newTitle: string = this.componentList.title;\r\n    this.titleService.setTitle( newTitle );\r\n  }\r\n\r\n  /**\r\n   * Set the component according to requested form\r\n   * @param formName Name of the form to open\r\n   * @param taskId Id of opening task\r\n   * @param taskDescription TODO\r\n   * @param isModal whether modal window is being opened\r\n   */\r\n  private setComponent(formName: string, taskId: string, taskDescription: string, isModal: boolean) {\r\n    this.pendingCommandsCollector.startCollecting();\r\n\r\n    if(isModal) {\r\n      this.overlayWindowService.open(formName, taskId, taskDescription);\r\n    }\r\n    else {\r\n      this.RootComponent = this.componentList.getComponent(formName);\r\n      this.RootComponentParameters = { taskIdParam: taskId, taskDescription: taskDescription };\r\n    }\r\n    this.changeDetectorRef.detectChanges();\r\n  }\r\n\r\n  /**\r\n   * @ignore\r\n   */\r\n  registerUICommands() {\r\n    this.engineMagicService.refreshDom.pipe(\r\n      filter(command => command.TaskTag === '0'))\r\n      .subscribe(command => {\r\n        this.executeCommand(command);\r\n      });\r\n    this.engineMagicService\r\n      .interactiveCommands.pipe(\r\n      filter(command => command.TaskTag === '0'))\r\n      .subscribe(command => {\r\n        GuiInteractiveExecutor.executeInteractiveCommand(null, command, this.overlayWindowService);\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Execute commands received from the Magic WebClient engine\r\n   * @param command\r\n   */\r\n  executeCommand(command: GuiCommand): void {\r\n    switch (command.CommandType) {\r\n      case CommandType.OPEN_FORM:\r\n          this.setComponent(command.str, command.stringList[0], command.stringList[1], command.Bool1);\r\n          break;\r\n\r\n      case CommandType.SET_IS_LOGGED_IN:\r\n        this.engineMagicService.setIsLoggedIn(command.Bool1);\r\n        break;\r\n\r\n      case CommandType.CLOSE_FORM:\r\n        if (this.RootComponent != null && command.str === this.RootComponentParameters.taskIdParam) {\r\n          this.RootComponent = null;\r\n          this.RootComponentParameters = {};\r\n\r\n          this.changeDetectorRef.detectChanges();\r\n        }\r\n        else { // Close modal window\r\n          this.overlayWindowService.close(command.str);\r\n          this.changeDetectorRef.detectChanges();\r\n        }\r\n        break;\r\n\r\n      case CommandType.RELOAD_PAGE:\r\n        window.location.reload();\r\n        break;\r\n\r\n      case CommandType.SHOW_SPINNER:\r\n        if (this.showSpinner != command.Bool1) {\r\n          this.showSpinner = command.Bool1;\r\n          this.changeDetectorRef.detectChanges();\r\n        }\r\n        break;\r\n\r\n      case CommandType.EXIT_MAGIC:\r\n        if (this.exitMagicService)\r\n          this.exitMagicService.exitMagic();\r\n        break;\r\n\r\n      case CommandType.SHOW_HTML_ERROR:\r\n        window.document.write(command.str);\r\n        break;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/src/ui/mgerror.magic.component.mjs

@@ -0,0 +1,125 @@
+import { ChangeDetectorRef, Component, ElementRef, Input, ViewChild } from "@angular/core";
+import { AccessorMagicService } from "../services/accessor.magic.service";
+import { TaskMagicService } from "../services/task.magics.service";
+import { isUndefined } from "@magic-xpa/mscorelib";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/task.magics.service";
+import * as i2 from "../services/accessor.magic.service";
+import * as i3 from "@angular/common";
+const _c0 = ["customContent"];
+const _c1 = ["*"];
+function ErrorMagicComponent_div_0_span_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span");
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate1(" ", ctx_r0.mgService.getErrMsg(ctx_r0.id, ctx_r0.rowId), " ");
+} }
+function ErrorMagicComponent_div_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div")(1, "div", null, 0);
+    i0.ɵɵprojection(3);
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(4, ErrorMagicComponent_div_0_span_4_Template, 2, 1, "span", 1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(4);
+    i0.ɵɵproperty("ngIf", ctx_r0.defaultDisplay);
+} }
+export class ErrorMagicComponent {
+    _task;
+    mgService;
+    changeDetectorRef;
+    id;
+    rowId;
+    set magic(val) {
+        this.id = val;
+    }
+    ;
+    set rowId1(val) {
+        this.rowId = val;
+    }
+    ;
+    defaultDisplay = true;
+    set CustomContent(innerComponent) {
+        this.defaultDisplay = innerComponent == undefined || this.isEmpty(innerComponent.nativeElement);
+        this.changeDetectorRef.detectChanges();
+    }
+    ;
+    constructor(_task, mgService, changeDetectorRef) {
+        this._task = _task;
+        this.mgService = mgService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.rowId = "0";
+    }
+    isEmpty(element) {
+        const nodes = element.childNodes;
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes.item(i);
+            if (node.nodeType !== 8 && nodes.item(i).textContent.trim().length !== 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    HasErrors(id) {
+        if (!isUndefined(id)) {
+            let control = this._task.getFormControl(this.rowId, id);
+            if (control !== null) {
+                if (control.dirty && (control.hasError('pattern') || control.hasError('required') ||
+                    control.hasError('rangevalidator') || control.hasError('maxlength') || control.hasError('max')))
+                    return true;
+                if (control.touched && control.hasError('required'))
+                    return true;
+                if (this._task.Records.list[this.rowId] && this._task.Records.list[this.rowId].getControlMetadata(id)) {
+                    let controlMetadata = this._task.Records.list[this.rowId].getControlMetadata(id);
+                    for (let customValidator of controlMetadata.customValidators.keys()) {
+                        if (control.hasError(customValidator))
+                            return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    static ɵfac = function ErrorMagicComponent_Factory(t) { return new (t || ErrorMagicComponent)(i0.ɵɵdirectiveInject(i1.TaskMagicService), i0.ɵɵdirectiveInject(i2.AccessorMagicService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); };
+    static ɵcmp = i0.ɵɵdefineComponent({ type: ErrorMagicComponent, selectors: [["mgError"]], viewQuery: function ErrorMagicComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.CustomContent = _t.first);
+        } }, inputs: { magic: "magic", rowId1: [i0.ɵɵInputFlags.None, "rowId", "rowId1"] }, ngContentSelectors: _c1, decls: 1, vars: 1, consts: [["customContent", ""], [4, "ngIf"]], template: function ErrorMagicComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵtemplate(0, ErrorMagicComponent_div_0_Template, 5, 1, "div", 1);
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngIf", ctx.HasErrors(ctx.id));
+        } }, dependencies: [i3.NgIf], encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ErrorMagicComponent, [{
+        type: Component,
+        args: [{
+                selector: 'mgError',
+                template: `<div *ngIf="HasErrors(id)">
+    <div #customContent>
+      <ng-content></ng-content>
+    </div>
+     <span *ngIf="defaultDisplay">
+      {{mgService.getErrMsg(id, rowId)}} 
+    </span>
+    </div>
+`
+            }]
+    }], () => [{ type: i1.TaskMagicService }, { type: i2.AccessorMagicService }, { type: i0.ChangeDetectorRef }], { magic: [{
+            type: Input,
+            args: ['magic']
+        }], rowId1: [{
+            type: Input,
+            args: ['rowId']
+        }], CustomContent: [{
+            type: ViewChild,
+            args: ['customContent', { static: false }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ErrorMagicComponent, { className: "ErrorMagicComponent", filePath: "src\\ui\\mgerror.magic.component.ts", lineNumber: 22 }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/ui/pipes/date.magic.pipe.mjs

@@ -0,0 +1,106 @@
+import { Pipe } from '@angular/core';
+import { DatePipe } from '@angular/common';
+import { TaskMagicService } from '../../services/task.magics.service';
+import { StringBuilder, isNullOrUndefined } from "@magic-xpa/mscorelib";
+import { PICInterface } from "@magic-xpa/utils";
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/task.magics.service";
+export class Constants {
+    static DATE_FMT = 'dd/MMM/yyyy';
+}
+export class DateMagicPipe extends DatePipe {
+    _task;
+    constructor(_task) {
+        super('en-US');
+        this._task = _task;
+    }
+    transform(value, controlId) {
+        let mask = this._task.GetControlPictureMask(controlId).getMask();
+        let formatStr = null;
+        let mgDateFormatter = new MgDateFormatter();
+        if (!isNullOrUndefined(value) && mask !== null) {
+            formatStr = mgDateFormatter.ConvertMgDateFormatToAngular(mask);
+            if (formatStr != null && this._task.isTableControl(controlId)) {
+                if (this._task.mgInputDateFormat == null)
+                    this._task.mgInputDateFormat = formatStr;
+                else
+                    formatStr = this._task.mgInputDateFormat;
+            }
+            return super.transform(value, formatStr);
+        }
+        else
+            value = "";
+        return value;
+    }
+    static ɵfac = function DateMagicPipe_Factory(t) { return new (t || DateMagicPipe)(i0.ɵɵdirectiveInject(i1.TaskMagicService, 16)); };
+    static ɵpipe = i0.ɵɵdefinePipe({ name: "magicDate", type: DateMagicPipe, pure: true });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DateMagicPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'magicDate'
+            }]
+    }], () => [{ type: i1.TaskMagicService }], null); })();
+export class MgDateFormatter {
+    ConvertMgDateFormatToAngular(mgDateMask) {
+        let formatStr = new StringBuilder();
+        if (mgDateMask !== null) {
+            for (let i = 0; i < mgDateMask.length;) {
+                switch (mgDateMask.charCodeAt(i)) {
+                    case PICInterface.PIC_YYYY:
+                        formatStr.Append('yyyy');
+                        i += 4;
+                        break;
+                    case PICInterface.PIC_MMD:
+                        formatStr.Append('MM');
+                        i += 2;
+                        break;
+                    case PICInterface.PIC_YY:
+                        formatStr.Append('yy');
+                        i += 2;
+                        break;
+                    case PICInterface.PIC_MMM:
+                        {
+                            let cnt = 0;
+                            for (; i < mgDateMask.length; i++)
+                                if (mgDateMask.charCodeAt(i) == PICInterface.PIC_MMM)
+                                    cnt++;
+                                else
+                                    break;
+                            if (cnt == 3)
+                                formatStr.Append('MMM');
+                            if (cnt > 3)
+                                formatStr.Append('MMMM');
+                        }
+                        break;
+                    case PICInterface.PIC_DD:
+                        formatStr.Append('dd');
+                        i += 2;
+                        break;
+                    case PICInterface.PIC_WWW:
+                        {
+                            let cnt = 0;
+                            for (; i < mgDateMask.length; i++)
+                                if (mgDateMask.charCodeAt(i) == PICInterface.PIC_WWW)
+                                    cnt++;
+                                else
+                                    break;
+                            if (cnt == 3)
+                                formatStr.Append('EEE');
+                            if (cnt > 3)
+                                formatStr.Append('EEEE');
+                        }
+                        break;
+                    default:
+                        formatStr.Append(mgDateMask.charAt(i));
+                        i++;
+                        break;
+                }
+            }
+            return formatStr.ToString();
+        }
+        else
+            return "dd-mm-yyyy";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date.magic.pipe.js","sourceRoot":"","sources":["../../../../../../../projects/angular/src/ui/pipes/date.magic.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import { Pipe, PipeTransform } from '@angular/core';\r\nimport { DatePipe } from '@angular/common';\r\nimport {TaskMagicService} from '../../services/task.magics.service';\r\nimport {StringBuilder, isNullOrUndefined} from \"@magic-xpa/mscorelib\"\r\nimport {PICInterface} from \"@magic-xpa/utils\"\r\n\r\n\r\n/**\r\n * @ignore\r\n */\r\nexport class Constants {\r\n  static readonly DATE_FMT = 'dd/MMM/yyyy';\r\n}\r\n\r\n/**\r\n * @ignore\r\n */\r\n@Pipe({\r\n  name: 'magicDate'\r\n})\r\nexport class DateMagicPipe extends DatePipe implements PipeTransform {\r\n\r\n  constructor(protected _task: TaskMagicService) {\r\n    super('en-US');\r\n\r\n    }\r\n\r\n  transform(value: any, controlId: string): any {\r\n\r\n    let mask: string = this._task.GetControlPictureMask (controlId).getMask();\r\n    let formatStr: string = null;\r\n    let mgDateFormatter = new MgDateFormatter();\r\n    if (!isNullOrUndefined(value) && mask !== null) {\r\n      formatStr = mgDateFormatter.ConvertMgDateFormatToAngular (mask);\r\n      // If control is label control of table, due to query mode, then save the format here.\r\n      if (formatStr != null && this._task.isTableControl(controlId)) {\r\n        if (this._task.mgInputDateFormat == null)\r\n          this._task.mgInputDateFormat = formatStr;\r\n        else\r\n          formatStr = this._task.mgInputDateFormat;\r\n      }\r\n      return super.transform(value, formatStr);\r\n    }\r\n    else\r\n      value = \"\";\r\n\r\n    return value;\r\n  }\r\n}\r\n\r\nexport  class MgDateFormatter {\r\n\r\n  ConvertMgDateFormatToAngular(mgDateMask: string) : string\r\n  {\r\n    let formatStr: StringBuilder = new StringBuilder ();\r\n\r\n    if (mgDateMask !== null) {\r\n      for (let i: number = 0; i < mgDateMask.length;) {\r\n        switch (mgDateMask.charCodeAt(i)) {\r\n          case PICInterface.PIC_YYYY:\r\n            formatStr.Append('yyyy');\r\n            i += 4;\r\n            break;\r\n          case PICInterface.PIC_MMD:\r\n            formatStr.Append('MM');\r\n            i += 2;\r\n            break;\r\n          case PICInterface.PIC_YY:\r\n            formatStr.Append('yy');\r\n            i += 2;\r\n            break;\r\n          case PICInterface.PIC_MMM:\r\n          {\r\n            let cnt = 0;\r\n            for  (;i < mgDateMask.length; i++)\r\n              if (mgDateMask.charCodeAt(i) == PICInterface.PIC_MMM)\r\n                cnt++;\r\n              else\r\n                break;\r\n\r\n            if (cnt == 3)\r\n              formatStr.Append('MMM');\r\n            if (cnt > 3)\r\n              formatStr.Append('MMMM');\r\n          }\r\n\r\n            break;\r\n          case PICInterface.PIC_DD:\r\n            formatStr.Append('dd');\r\n            i += 2;\r\n\r\n            break;\r\n\r\n          case PICInterface.PIC_WWW: {\r\n            let cnt = 0;\r\n            for  (;i < mgDateMask.length; i++)\r\n              if (mgDateMask.charCodeAt(i) == PICInterface.PIC_WWW)\r\n                cnt++;\r\n              else\r\n                break;\r\n\r\n            if (cnt == 3)\r\n              formatStr.Append('EEE');\r\n            if (cnt > 3)\r\n              formatStr.Append('EEEE');\r\n            }\r\n\r\n            break;\r\n\r\n          default:\r\n            formatStr.Append(mgDateMask.charAt(i));\r\n            i++;\r\n            break;\r\n        }\r\n      }\r\n      return formatStr.ToString();\r\n    }\r\n    else\r\n      return \"dd-mm-yyyy\"; // return default format.\r\n\r\n  }\r\n}\r\n"]}

package/esm2022/src/ui/pipes/time.magic.pipe.mjs

@@ -0,0 +1,52 @@
+import { Pipe } from '@angular/core';
+import { DatePipe } from '@angular/common';
+import { TaskMagicService } from '../../services/task.magics.service';
+import { StringBuilder } from "@magic-xpa/mscorelib";
+import { PICInterface } from "@magic-xpa/utils";
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/task.magics.service";
+export class TimeMagicPipe extends DatePipe {
+    _task;
+    constructor(_task) {
+        super('en-US');
+        this._task = _task;
+    }
+    transform(value, controlId) {
+        let mask = this._task.GetControlPictureMask(controlId).getMask();
+        let formatStr = new StringBuilder();
+        if (typeof value !== "undefined" && mask !== null) {
+            for (let i = 0; i < mask.length;) {
+                switch (mask.charCodeAt(i)) {
+                    case PICInterface.PIC_HH:
+                        formatStr.Append('hh');
+                        i += 2;
+                        break;
+                    case PICInterface.PIC_MMT:
+                        formatStr.Append('mm');
+                        i += 2;
+                        break;
+                    case PICInterface.PIC_SS:
+                        formatStr.Append('ss');
+                        i += 2;
+                        break;
+                    default:
+                        formatStr.Append(mask.charAt(i));
+                        i++;
+                        break;
+                }
+            }
+            formatStr.Append(' a');
+            return super.transform(value, formatStr.ToString());
+        }
+        return value;
+    }
+    static ɵfac = function TimeMagicPipe_Factory(t) { return new (t || TimeMagicPipe)(i0.ɵɵdirectiveInject(i1.TaskMagicService, 16)); };
+    static ɵpipe = i0.ɵɵdefinePipe({ name: "magicTime", type: TimeMagicPipe, pure: true });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TimeMagicPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'magicTime'
+            }]
+    }], () => [{ type: i1.TaskMagicService }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/ui/pipes/time24.magic.pipe.mjs

@@ -0,0 +1,35 @@
+import { Pipe } from '@angular/core';
+import { TaskMagicService } from "../../services/task.magics.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/task.magics.service";
+export class Time24MagicPipe {
+    _task;
+    constructor(_task) {
+        this._task = _task;
+    }
+    transform(value, controlId) {
+        let mask = this._task.GetControlPictureMask(controlId).getMask();
+        if (typeof value !== "undefined" && mask !== null) {
+            const date = new Date(value);
+            const hours = date.getHours().toString().padStart(2, '0');
+            const minutes = date.getMinutes().toString().padStart(2, '0');
+            const seconds = date.getSeconds().toString().padStart(2, '0');
+            if (mask.length == 5) {
+                return `${hours}:${minutes}`;
+            }
+            else if (mask.length > 5) {
+                return `${hours}:${minutes}:${seconds}`;
+            }
+        }
+        return value;
+    }
+    static ɵfac = function Time24MagicPipe_Factory(t) { return new (t || Time24MagicPipe)(i0.ɵɵdirectiveInject(i1.TaskMagicService, 16)); };
+    static ɵpipe = i0.ɵɵdefinePipe({ name: "magicTime24", type: Time24MagicPipe, pure: true });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(Time24MagicPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'magicTime24'
+            }]
+    }], () => [{ type: i1.TaskMagicService }], null); })();
+//# sourceMappingURL=data:application/json;base64,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