@magic-xpa/angular 4.1100.0-dev4110.106 → 4.1100.0-dev4110.107

package/README.md

@@ -1,5 +1,5 @@
-# Magic-xpa/angular
-
-This package is part of Magic xpa Web Application Framework. 
-It is used to easily create modern business apps powered by Angular to provide a rich user experience and meet the increasingly complex enterprise business expectations for digital transformation. 
-  
+# Magic-xpa/angular
+
+This package is part of Magic xpa Web Application Framework. 
+It is used to easily create modern business apps powered by Angular to provide a rich user experience and meet the increasingly complex enterprise business expectations for digital transformation. 
+  

package/esm2020/index.mjs

@@ -1,2 +1,59 @@
-export * from "./index";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZmlsZSBBdXRvbWF0aWNhbGx5IGdlbmVyYXRlZCBieSBiYXJyZWxzYnkuXG4gKi9cblxuZXhwb3J0ICogZnJvbSBcIi4vaW5kZXhcIjtcbiJdfQ==
+export * from "./src/controls.metadata.model";
+export * from "./src/magic.core.module";
+export * from "./src/interfaces/sub-form-definition.iterface";
+export * from "./src/services/accessor.magic.service";
+export * from "./src/services/commands-collector.magic.service";
+export * from "./src/services/component-list.magic.service";
+export * from "./src/services/confirmation.components.magic.provider";
+export * from "./src/services/engine.magic.service";
+export * from "./src/services/exit.magic.service";
+export * from "./src/services/ISubformMagicService";
+export * from "./src/services/magic-color.service";
+export * from "./src/services/magic.lazy.loader.service";
+export * from "./src/services/magic.providers";
+export * from "./src/services/magic.services";
+export * from "./src/services/mg-date-adapter";
+export * from "./src/services/overlay.conainer.magic.provider";
+export * from "./src/services/OverlayWindowService";
+export * from "./src/services/router-commands.magic.service";
+export * from "./src/services/StylesMapManager";
+export * from "./src/services/subform.magic.service";
+export * from "./src/services/table.magic.service";
+export * from "./src/services/task.magics.service";
+export * from "./src/services/title.magic.service";
+export * from "./src/ui/GuiInteractiveExecutor";
+export * from "./src/ui/magic-confirmationBox";
+export * from "./src/ui/magic-root.component";
+export * from "./src/ui/mgerror.magic.component";
+export * from "./src/ui/router-container.magic.component";
+export * from "./src/ui/subform.magic.component";
+export * from "./src/ui/task-base.magic.component";
+export * from "./src/ui/utils";
+export * from "./src/ui/components/base-magic-alert.component";
+export * from "./src/ui/components/base-magic-confirm.component";
+export * from "./src/ui/components/magic-alert.component";
+export * from "./src/ui/components/magic-confirmation-box.component";
+export * from "./src/ui/directives/magic-focus.directive";
+export * from "./src/ui/directives/magic.directive";
+export * from "./src/ui/directives/magicViewContainerRef.directive";
+export * from "./src/ui/directives/mgformat.magic.directive";
+export * from "./src/ui/directives/NonMagicControlDirective";
+export * from "./src/ui/directives/range-validator.magic.directive";
+export * from "./src/ui/directives/magic/checkbox-noformcontrol.magic.directive";
+export * from "./src/ui/directives/magic/checkbox.magic.directive";
+export * from "./src/ui/directives/magic/combobox.magic.directive";
+export * from "./src/ui/directives/magic/input.noformcontrol.magic.directive";
+export * from "./src/ui/directives/magic/nocontrol.magic.directive";
+export * from "./src/ui/directives/magic/row.magic.directive";
+export * from "./src/ui/directives/magic/form-controls/control-value-accessors/checkbox.cva.directive";
+export * from "./src/ui/directives/magic/form-controls/control-value-accessors/date.cva.directive";
+export * from "./src/ui/directives/magic/form-controls/control-value-accessors/default.cva.directive";
+export * from "./src/ui/magic-modal/base-magic-overlay-container";
+export * from "./src/ui/magic-modal/magic-modal-form";
+export * from "./src/ui/magic-modal/magic-modal-interface";
+export * from "./src/ui/magic-modal/magic-overlay-container-wrapper";
+export * from "./src/ui/magic-modal/magic-overlay-container";
+export * from "./src/ui/pipes/date.magic.pipe";
+export * from "./src/ui/pipes/time.magic.pipe";
+export * from "./src/ui/pipes/time24.magic.pipe";
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/controls.metadata.model.mjs

@@ -0,0 +1,180 @@
+import { isNullOrUndefined } from "@magic-xpa/mscorelib";
+export class ControlMetadata {
+    constructor() {
+        this.properties = new Map();
+        this.classesMap = new Map();
+        this.stylesMap = new Map();
+        this.userProperties = new Map();
+        this.customValidators = new Map();
+    }
+    setClass(key, value) {
+        if (this.classesMap.has(key)) {
+            this.removedClass = this.classesMap.get(key);
+        }
+        this.classesMap.set(key, value);
+        let result = '';
+        for (let value of this.classesMap) {
+            result += value + ' ';
+        }
+        this.classes = result;
+    }
+    setStyle(key, value) {
+        this.stylesMap.set(key, value);
+    }
+}
+export class ControlsMetadata {
+    constructor() {
+        this.values = new Map();
+        this.ControlsProperties = new Map();
+        this.isCreated = false;
+        this.isEditing = false;
+    }
+    get Values() {
+        return this.values;
+    }
+    getControlMetadata(controlId) {
+        if (!this.ControlsProperties.has(controlId))
+            this.ControlsProperties.set(controlId, new ControlMetadata());
+        return this.ControlsProperties.get(controlId);
+    }
+    update(obj) {
+        let props = obj.ControlsMetaData;
+        for (let controlName in props) {
+            if (!this.ControlsProperties.has(controlName))
+                this.ControlsProperties.set(controlName, new ControlMetadata());
+            let controlMetaData = this.ControlsProperties.get(controlName);
+            for (let property in obj.ControlsMetaData[controlName].Properties)
+                controlMetaData[property] = obj.ControlsMetaData[controlName].Properties[property];
+            controlMetaData.controlType = obj.ControlsMetaData[controlName].Type;
+        }
+        for (let controlName in obj.ControlsValues) {
+            this.setValue(controlName, obj.ControlsValues[controlName]);
+        }
+    }
+    setValue(controlName, value) {
+        this.values.set(controlName, value);
+    }
+    getProperty(controlId, prop) {
+        if (this.ControlsProperties.has(controlId)) {
+            if (this.ControlsProperties.get(controlId).properties.has(prop)) {
+                return this.ControlsProperties.get(controlId).properties.get(prop);
+            }
+        }
+        return "";
+    }
+    getValue(controlName) {
+        return this.values.get(controlName);
+    }
+}
+export class Records {
+    constructor() {
+        this.data = new Map();
+        this.list = [];
+        this.recordsBeforeCurrentView = 0;
+        this.isEmptyDataView = false;
+        this.sizeUpdated = false;
+    }
+    getRow(dvRowId) {
+        return this.list[dvRowId + this.recordsBeforeCurrentView];
+    }
+    markRowAsCreated(guiRowId) {
+        if (guiRowId < this.list.length) {
+            this.addRow(guiRowId);
+            this.data.get(guiRowId).isCreated = true;
+        }
+    }
+    markRowAsNotCreated(guiRowId) {
+        if (guiRowId < this.list.length)
+            this.data.get(guiRowId).isCreated = false;
+    }
+    isRowCreated(guiRowId) {
+        if (guiRowId < this.list.length) {
+            if (!this.data.has(guiRowId) || isNullOrUndefined(this.data.get(guiRowId)))
+                return false;
+            else
+                return this.data.get(guiRowId).isCreated;
+        }
+        return false;
+    }
+    startRowEditing(guiRowId) {
+        if (guiRowId < this.list.length && this.data.has(guiRowId))
+            this.data.get(guiRowId).isEditing = true;
+    }
+    stopRowEditing(guiRowId) {
+        if (guiRowId < this.list.length && this.data.has(guiRowId))
+            this.data.get(guiRowId).isEditing = false;
+    }
+    isRowInRowEditing(guiRowId) {
+        if (+guiRowId < this.list.length) {
+            if (!this.data.has(+guiRowId) || isNullOrUndefined(this.data.get(+guiRowId)))
+                return false;
+            else
+                return this.data.get(+guiRowId).isEditing;
+        }
+        return false;
+    }
+    update(obj) {
+        if (obj.fullRefresh && obj.rows.length != this.list.length) {
+            this.data = new Map();
+            this.list = new Array();
+        }
+        for (let rowId in obj.rows) {
+            if (!this.data.has(+rowId) || this.data.get(+rowId) === null)
+                this.data.set(+rowId, new ControlsMetadata());
+            let controlsData = this.data.get(+rowId);
+            controlsData.update(obj.rows[rowId]);
+            controlsData.rowId = rowId;
+        }
+        for (var [key, value] of this.data) {
+            this.list[key] = value;
+        }
+    }
+    updateSize(len) {
+        if (this.list.length != len) {
+            if (len < this.list.length) {
+                for (let i = len; i < this.list.length; i++) {
+                    this.data.delete(i);
+                }
+            }
+            this.list.length = len;
+            this.sizeUpdated = true;
+        }
+    }
+    clearFirstTableRecord(template) {
+        if (this.list.length >= 1) {
+            for (const key in template) {
+                if (template[key] == '1' && this.list[0].ControlsProperties.has(key)) {
+                    this.list[0].ControlsProperties.get(key).properties = new Map();
+                }
+            }
+        }
+    }
+    addRow(guiRowId) {
+        if (guiRowId !== 0 || !this.data.has(guiRowId) || isNullOrUndefined(this.data.get(guiRowId))) {
+            this.data.set(guiRowId, new ControlsMetadata());
+            this.data.get(guiRowId).rowId = "" + guiRowId;
+            this.list[guiRowId] = this.data.get(guiRowId);
+        }
+    }
+    createFirst() {
+        this.addRow(0);
+    }
+    fromJson(data) {
+        var obj = JSON.parse(data);
+        this.update(obj);
+    }
+    setGuiTopIndex(topIndex) {
+        this.guiTopIndex = topIndex;
+    }
+    getGuiTopIndex() {
+        return this.guiTopIndex;
+    }
+}
+export var HtmlClasses;
+(function (HtmlClasses) {
+    HtmlClasses["Color"] = "color";
+    HtmlClasses["font"] = "font";
+    HtmlClasses["FocusColor"] = "focuscolor";
+    HtmlClasses["HintColor"] = "hintcolor";
+})(HtmlClasses || (HtmlClasses = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controls.metadata.model.js","sourceRoot":"","sources":["../../../../../projects/angular/src/controls.metadata.model.ts"],"names":[],"mappings":"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","sourcesContent":["import {StorageAttribute} from \"@magic-xpa/utils\";\r\nimport { isNullOrUndefined } from \"@magic-xpa/mscorelib\";\r\nimport {HtmlProperties, CustomValidator} from  \"@magic-xpa/gui\";\r\n\r\n/**\r\n * @ignore\r\n */\r\nexport class ControlMetadata {\r\n  controlType: string;\r\n  dataType: StorageAttribute;\r\n  properties: Map<HtmlProperties, any> = new Map();\r\n  classesMap: Map<HtmlClasses, any> = new Map();\r\n  stylesMap: Map<HtmlClasses, any> = new Map();\r\n  removedClass: string;\r\n  classes: string  ;\r\n  rangeValidator: boolean;\r\n\r\n  // user properties\r\n  userProperties: Map<string, any> = new Map();\r\n\r\n  customValidators: Map<string, CustomValidator> = new Map();\r\n\r\n  setClass(key, value) {\r\n    // for no-control - hold the name of the class to be removed later\r\n    if(this.classesMap.has(key)) {\r\n      this.removedClass = this.classesMap.get(key);\r\n    }\r\n\r\n    this.classesMap.set(key, value);\r\n    let result = '';\r\n\r\n    for (let value of this.classesMap) {\r\n      result += value + ' ';\r\n    }\r\n    this.classes = result;\r\n\r\n  }\r\n\r\n  setStyle(key, value) {\r\n    this.stylesMap.set(key, value);\r\n  }\r\n\r\n}\r\n\r\n/**\r\n * @ignore\r\n */\r\nexport class ControlsMetadata {\r\n\r\n  //values of control\r\n  values: Map<string, string> = new Map();\r\n  // dictionary of controls with there properties\r\n  ControlsProperties: Map<string, ControlMetadata> = new Map();\r\n\r\n  rowId: string;\r\n  isCreated = false;\r\n  isEditing = false;\r\n\r\n  get Values(){\r\n    return this.values;\r\n  }\r\n\r\n  getControlMetadata(controlId: string) {\r\n    if (!this.ControlsProperties.has(controlId))\r\n      this.ControlsProperties.set(controlId, new ControlMetadata());\r\n    return this.ControlsProperties.get(controlId);\r\n  }\r\n\r\n\r\n\r\n  update(obj:any) {\r\n    //should we keep the values here ?\r\n    //this.values = obj.ControlsValues;\r\n    let props: { [id: string]: { [id: string]: string; } } = obj.ControlsMetaData;\r\n    for (let controlName in props) {\r\n      if (!this.ControlsProperties.has(controlName))\r\n        this.ControlsProperties.set(controlName, new ControlMetadata());\r\n      let controlMetaData: ControlMetadata = this.ControlsProperties.get(controlName);\r\n      for (let property in obj.ControlsMetaData[controlName].Properties)\r\n        controlMetaData[property] = obj.ControlsMetaData[controlName].Properties[property];\r\n      controlMetaData.controlType = obj.ControlsMetaData[controlName].Type;\r\n    }\r\n    for (let controlName in obj.ControlsValues) {\r\n      this.setValue(controlName, obj.ControlsValues[controlName]);\r\n    }\r\n  }\r\n\r\n  setValue(controlName: string, value: any): void  {\r\n    this.values.set(controlName, value);\r\n  }\r\n\r\n  getProperty(controlId: string, prop: HtmlProperties) {\r\n    if (this.ControlsProperties.has(controlId)) {\r\n      if (this.ControlsProperties.get(controlId).properties.has(prop)) {\r\n        return this.ControlsProperties.get(controlId).properties.get(prop);\r\n      }\r\n    }\r\n    return \"\";\r\n  }\r\n\r\n\r\n  getValue(controlName: string){\r\n    return this.values.get(controlName);\r\n  }\r\n\r\n\r\n}\r\n\r\n/**\r\n * @ignore\r\n */\r\nexport class Records {\r\n  data: Map<number, ControlsMetadata> = new Map();\r\n  list: ControlsMetadata[] = []; //used for sequential access in table\r\n  includesFirst: boolean;\r\n  includesLast: boolean;\r\n  guiTopIndex: number;\r\n  recordsBeforeCurrentView: number = 0;\r\n  isEmptyDataView: boolean = false;\r\n  sizeUpdated: boolean = false; //used for evaluating the RecordsSizeChange.\r\n\r\n  getRow(dvRowId: number): ControlsMetadata {\r\n    return this.list[dvRowId + this.recordsBeforeCurrentView];\r\n  }\r\n\r\n  markRowAsCreated(guiRowId: number): void {\r\n    if (guiRowId < this.list.length) {\r\n      this.addRow(guiRowId);\r\n      this.data.get(guiRowId).isCreated = true;\r\n    }\r\n  }\r\n\r\n  markRowAsNotCreated(guiRowId: number): void {\r\n    if (guiRowId < this.list.length)\r\n      this.data.get(guiRowId).isCreated = false;\r\n  }\r\n\r\n\r\n  isRowCreated(guiRowId: number): boolean {\r\n    if (guiRowId < this.list.length) {\r\n      if (!this.data.has(guiRowId) || isNullOrUndefined(this.data.get(guiRowId)))\r\n        return false;\r\n      else\r\n        return this.data.get(guiRowId).isCreated;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /*\r\n  * for row editing\r\n  * */\r\n  startRowEditing(guiRowId: number): void {\r\n    if (guiRowId < this.list.length && this.data.has(guiRowId))\r\n      this.data.get(guiRowId).isEditing = true;\r\n  }\r\n\r\n  /*\r\n  * stop row editing on row Id\r\n  * */\r\n  stopRowEditing(guiRowId: number): void {\r\n    if (guiRowId < this.list.length && this.data.has(guiRowId))\r\n      this.data.get(guiRowId).isEditing = false;\r\n  }\r\n\r\n  /*\r\n  * return if row is in editing\r\n  * Called by the HTML code, so parameter is a string, not a numebr\r\n  * */\r\n  isRowInRowEditing(guiRowId: string): boolean {\r\n    if (+guiRowId < this.list.length) {\r\n      if (!this.data.has(+guiRowId) || isNullOrUndefined(this.data.get(+guiRowId)))\r\n        return false;\r\n      else\r\n        return this.data.get(+guiRowId).isEditing;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  update(obj) {\r\n\r\n    if (obj.fullRefresh && obj.rows.length != this.list.length) {\r\n      this.data = new Map();\r\n      this.list = new Array<ControlsMetadata>();\r\n    }\r\n    for (let rowId in obj.rows) {\r\n      if (!this.data.has(+rowId) || this.data.get(+rowId) === null)\r\n        this.data.set(+rowId, new ControlsMetadata());\r\n      let controlsData: ControlsMetadata = this.data.get(+rowId);\r\n      controlsData.update(obj.rows[rowId]);\r\n      controlsData.rowId = rowId;\r\n    }\r\n    for (var [key, value] of this.data) {\r\n      this.list[key] = value;\r\n    }\r\n\r\n  }\r\n\r\n  updateSize(len: number) {\r\n    if (this.list.length != len) {\r\n      if (len < this.list.length) {\r\n        //remove rows\r\n        for (let i = len; i < this.list.length; i++) {\r\n          this.data.delete(i);\r\n        }\r\n\r\n      }\r\n      this.list.length = len;\r\n      this.sizeUpdated = true;\r\n\r\n    }\r\n  }\r\n\r\n\r\n  /**\r\n   * crears data for the first record\r\n   * @param template\r\n   */\r\n  clearFirstTableRecord(template: { [id: string]: string; }) {\r\n    if (this.list.length >= 1) {\r\n      for (const key in template) {\r\n        if (template[key] == '1' && this.list[0].ControlsProperties.has(key)) {\r\n          this.list[0].ControlsProperties.get(key).properties =  new Map() ;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  addRow(guiRowId: number) {\r\n    if (guiRowId !== 0 || !this.data.has(guiRowId) || isNullOrUndefined(this.data.get(guiRowId))) {\r\n      this.data.set(guiRowId, new ControlsMetadata());\r\n      this.data.get(guiRowId).rowId = \"\"+guiRowId;\r\n      this.list[guiRowId] = this.data.get(guiRowId);\r\n    }\r\n  }\r\n\r\n  createFirst() {\r\n    this.addRow(0);\r\n  }\r\n\r\n  fromJson(data: string) {\r\n    var obj = JSON.parse(data);\r\n    this.update(obj);\r\n  }\r\n\r\n  setGuiTopIndex(topIndex: number) {\r\n    this.guiTopIndex = topIndex;\r\n  }\r\n\r\n  getGuiTopIndex(): number {\r\n    return this.guiTopIndex;\r\n  }\r\n\r\n}\r\n\r\n  /**\r\n   * @ignore\r\n   */\r\nexport enum HtmlClasses {\r\n  Color = \"color\",\r\n  font = \"font\",\r\n  FocusColor=\"focuscolor\",\r\n  HintColor=\"hintcolor\",\r\n}\r\n"]}

package/esm2020/src/interfaces/sub-form-definition.iterface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ViLWZvcm0tZGVmaW5pdGlvbi5pdGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXIvc3JjL2ludGVyZmFjZXMvc3ViLWZvcm0tZGVmaW5pdGlvbi5pdGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVmlld0NvbnRhaW5lclJlZiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcblxyXG4vKipcclxuICogQGlnbm9yZVxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBTdWJmb3JtRGVmaW5pdGlvbiB7XHJcbiAgZm9ybU5hbWU6IHN0cmluZztcclxuICBwYXJhbWV0ZXJzOiBhbnk7XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBAaWdub3JlXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIFJvdXRlRGVmaW5pdGlvbiB7XHJcbiAgZm9ybU5hbWU6IHN0cmluZztcclxuICBwYXJhbWV0ZXJzOiBhbnk7XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSU1hZ2ljVmlld0NvbnRhaW5lclJlZiB7XHJcbiAgc2V0Vmlld0NvbnRhaW5lclJlZih2Y1JlZjogVmlld0NvbnRhaW5lclJlZik7XHJcbn1cclxuIl19

package/esm2020/src/magic.core.module.mjs

@@ -0,0 +1,160 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RouterModule } from '@angular/router';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { DynamicModule } from 'ng-dynamic-component';
+import { NoControlMagicDirective } from './ui/directives/magic/nocontrol.magic.directive';
+import { MagicOverlayContainer } from './ui/magic-modal/magic-overlay-container';
+import { RouterContainerMagicComponent } from './ui/router-container.magic.component';
+import { MgformatMagicDirective } from './ui/directives/mgformat.magic.directive';
+import { DateMagicPipe } from './ui/pipes/date.magic.pipe';
+import { TimeMagicPipe } from './ui/pipes/time.magic.pipe';
+import { RangeValidatorMagicDirective } from './ui/directives/range-validator.magic.directive';
+import { SubformMagicComponent } from './ui/subform.magic.component';
+import { ErrorMagicComponent } from './ui/mgerror.magic.component';
+import { CheckboxMagicDirective } from './ui/directives/magic/checkbox.magic.directive';
+import { ComboboxMagicDirective } from './ui/directives/magic/combobox.magic.directive';
+import { MagicShellComponent } from './ui/magic-root.component';
+import { MagicCheckboxControlValueAccessor } from './ui/directives/magic/form-controls/control-value-accessors/checkbox.cva.directive';
+import { MagicDefaultValueAccessor } from './ui/directives/magic/form-controls/control-value-accessors/default.cva.directive';
+import { MagicDirective } from './ui/directives/magic.directive';
+import { TaskBaseMagicComponent } from './ui/task-base.magic.component';
+import { RowMagicDirective } from './ui/directives/magic/row.magic.directive';
+import { CheckboxNoFormControlMagicDirective } from './ui/directives/magic/checkbox-noformcontrol.magic.directive';
+import { InputNoFormControlMagicDirective } from './ui/directives/magic/input.noformcontrol.magic.directive';
+import { DateValueAccessor } from './ui/directives/magic/form-controls/control-value-accessors/date.cva.directive';
+import { OverlayContainerMagicProvider } from './services/overlay.conainer.magic.provider';
+import { MagicOverlayContainerWrapper } from './ui/magic-modal/magic-overlay-container-wrapper';
+import { HttpClientModule } from '@angular/common/http';
+import { NonMagicControlDirective } from './ui/directives/NonMagicControlDirective';
+import { MagicAlertComponent } from './ui/components/magic-alert.component';
+import { ConfirmationComponentsMagicProvider } from './services/confirmation.components.magic.provider';
+import { MagicConfirmationBoxComponent } from './ui/components/magic-confirmation-box.component';
+import { MagicFocusDirective } from './ui/directives/magic-focus.directive';
+import { BaseMagicAlertComponent } from './ui/components/base-magic-alert.component';
+import { BaseMagicConfirmComponent } from './ui/components/base-magic-confirm.component';
+import { MagicViewContainerRef } from './ui/directives/magicViewContainerRef.directive';
+import { MaskitoModule } from "@maskito/angular";
+import { Time24MagicPipe } from "./ui/pipes/time24.magic.pipe";
+import * as i0 from "@angular/core";
+const decs = [
+    MagicDirective,
+    CheckboxMagicDirective,
+    CheckboxNoFormControlMagicDirective,
+    InputNoFormControlMagicDirective,
+    ComboboxMagicDirective,
+    RowMagicDirective,
+    MagicCheckboxControlValueAccessor,
+    MagicDefaultValueAccessor,
+    DateValueAccessor,
+    TaskBaseMagicComponent,
+    MagicOverlayContainer,
+    MagicAlertComponent,
+    MagicConfirmationBoxComponent,
+    BaseMagicAlertComponent,
+    BaseMagicConfirmComponent,
+    MagicOverlayContainerWrapper,
+    RouterContainerMagicComponent,
+    MagicShellComponent,
+    SubformMagicComponent,
+    ErrorMagicComponent,
+    NoControlMagicDirective,
+    MgformatMagicDirective,
+    DateMagicPipe,
+    TimeMagicPipe,
+    RangeValidatorMagicDirective,
+    NonMagicControlDirective,
+    MagicFocusDirective,
+    MagicViewContainerRef,
+    Time24MagicPipe
+];
+export class MagicModule {
+}
+MagicModule.ɵfac = function MagicModule_Factory(t) { return new (t || MagicModule)(); };
+MagicModule.ɵmod = i0.ɵɵdefineNgModule({ type: MagicModule });
+MagicModule.ɵinj = i0.ɵɵdefineInjector({ providers: [ConfirmationComponentsMagicProvider, OverlayContainerMagicProvider], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        RouterModule,
+        DynamicModule,
+        HttpClientModule, MaskitoModule] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MagicModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [...decs],
+                exports: [...decs, MaskitoModule],
+                entryComponents: [],
+                imports: [
+                    CommonModule,
+                    FormsModule,
+                    ReactiveFormsModule,
+                    RouterModule,
+                    DynamicModule,
+                    HttpClientModule
+                ],
+                providers: [ConfirmationComponentsMagicProvider, OverlayContainerMagicProvider]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(MagicModule, { declarations: [MagicDirective,
+        CheckboxMagicDirective,
+        CheckboxNoFormControlMagicDirective,
+        InputNoFormControlMagicDirective,
+        ComboboxMagicDirective,
+        RowMagicDirective,
+        MagicCheckboxControlValueAccessor,
+        MagicDefaultValueAccessor,
+        DateValueAccessor,
+        TaskBaseMagicComponent,
+        MagicOverlayContainer,
+        MagicAlertComponent,
+        MagicConfirmationBoxComponent,
+        BaseMagicAlertComponent,
+        BaseMagicConfirmComponent,
+        MagicOverlayContainerWrapper,
+        RouterContainerMagicComponent,
+        MagicShellComponent,
+        SubformMagicComponent,
+        ErrorMagicComponent,
+        NoControlMagicDirective,
+        MgformatMagicDirective,
+        DateMagicPipe,
+        TimeMagicPipe,
+        RangeValidatorMagicDirective,
+        NonMagicControlDirective,
+        MagicFocusDirective,
+        MagicViewContainerRef,
+        Time24MagicPipe], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        RouterModule,
+        DynamicModule,
+        HttpClientModule], exports: [MagicDirective,
+        CheckboxMagicDirective,
+        CheckboxNoFormControlMagicDirective,
+        InputNoFormControlMagicDirective,
+        ComboboxMagicDirective,
+        RowMagicDirective,
+        MagicCheckboxControlValueAccessor,
+        MagicDefaultValueAccessor,
+        DateValueAccessor,
+        TaskBaseMagicComponent,
+        MagicOverlayContainer,
+        MagicAlertComponent,
+        MagicConfirmationBoxComponent,
+        BaseMagicAlertComponent,
+        BaseMagicConfirmComponent,
+        MagicOverlayContainerWrapper,
+        RouterContainerMagicComponent,
+        MagicShellComponent,
+        SubformMagicComponent,
+        ErrorMagicComponent,
+        NoControlMagicDirective,
+        MgformatMagicDirective,
+        DateMagicPipe,
+        TimeMagicPipe,
+        RangeValidatorMagicDirective,
+        NonMagicControlDirective,
+        MagicFocusDirective,
+        MagicViewContainerRef,
+        Time24MagicPipe, MaskitoModule] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"magic.core.module.js","sourceRoot":"","sources":["../../../../../projects/angular/src/magic.core.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { RouterModule } from '@angular/router';\r\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\r\nimport { DynamicModule } from 'ng-dynamic-component';\r\nimport { NoControlMagicDirective } from './ui/directives/magic/nocontrol.magic.directive';\r\nimport { MagicOverlayContainer } from './ui/magic-modal/magic-overlay-container';\r\nimport { RouterContainerMagicComponent } from './ui/router-container.magic.component';\r\nimport { MgformatMagicDirective } from './ui/directives/mgformat.magic.directive';\r\nimport { DateMagicPipe } from './ui/pipes/date.magic.pipe';\r\nimport { TimeMagicPipe } from './ui/pipes/time.magic.pipe';\r\nimport { RangeValidatorMagicDirective } from './ui/directives/range-validator.magic.directive';\r\nimport { SubformMagicComponent } from './ui/subform.magic.component';\r\nimport { ErrorMagicComponent } from './ui/mgerror.magic.component';\r\nimport { CheckboxMagicDirective } from './ui/directives/magic/checkbox.magic.directive';\r\nimport { ComboboxMagicDirective } from './ui/directives/magic/combobox.magic.directive';\r\nimport { MagicShellComponent } from './ui/magic-root.component';\r\nimport { MagicCheckboxControlValueAccessor } from './ui/directives/magic/form-controls/control-value-accessors/checkbox.cva.directive';\r\nimport { MagicDefaultValueAccessor } from './ui/directives/magic/form-controls/control-value-accessors/default.cva.directive';\r\nimport { MagicDirective } from './ui/directives/magic.directive';\r\nimport { TaskBaseMagicComponent } from './ui/task-base.magic.component';\r\nimport { RowMagicDirective } from './ui/directives/magic/row.magic.directive';\r\nimport { CheckboxNoFormControlMagicDirective } from './ui/directives/magic/checkbox-noformcontrol.magic.directive';\r\nimport { InputNoFormControlMagicDirective } from './ui/directives/magic/input.noformcontrol.magic.directive';\r\nimport { DateValueAccessor } from './ui/directives/magic/form-controls/control-value-accessors/date.cva.directive';\r\nimport { OverlayContainerMagicProvider } from './services/overlay.conainer.magic.provider';\r\nimport { MagicOverlayContainerWrapper } from './ui/magic-modal/magic-overlay-container-wrapper';\r\nimport { HttpClientModule } from '@angular/common/http';\r\nimport { NonMagicControlDirective } from './ui/directives/NonMagicControlDirective';\r\nimport { MagicAlertComponent } from './ui/components/magic-alert.component';\r\nimport { ConfirmationComponentsMagicProvider } from './services/confirmation.components.magic.provider';\r\nimport { MagicConfirmationBoxComponent } from './ui/components/magic-confirmation-box.component';\r\nimport { MagicFocusDirective } from './ui/directives/magic-focus.directive';\r\nimport { BaseMagicAlertComponent } from './ui/components/base-magic-alert.component';\r\nimport { BaseMagicConfirmComponent } from './ui/components/base-magic-confirm.component';\r\nimport { MagicViewContainerRef } from './ui/directives/magicViewContainerRef.directive';\r\nimport { MaskitoModule } from \"@maskito/angular\";\r\nimport { Time24MagicPipe } from \"./ui/pipes/time24.magic.pipe\";\r\n/**\r\n * @ignore\r\n */\r\nconst decs = [\r\n  MagicDirective,\r\n  CheckboxMagicDirective,\r\n  CheckboxNoFormControlMagicDirective,\r\n  InputNoFormControlMagicDirective,\r\n  ComboboxMagicDirective,\r\n  RowMagicDirective,\r\n\r\n  MagicCheckboxControlValueAccessor,\r\n  MagicDefaultValueAccessor,\r\n  DateValueAccessor,\r\n  TaskBaseMagicComponent,\r\n  MagicOverlayContainer,\r\n  MagicAlertComponent,\r\n  MagicConfirmationBoxComponent,\r\n  BaseMagicAlertComponent,\r\n  BaseMagicConfirmComponent,\r\n  MagicOverlayContainerWrapper,\r\n  RouterContainerMagicComponent,\r\n  MagicShellComponent,\r\n  SubformMagicComponent,\r\n  ErrorMagicComponent,\r\n  NoControlMagicDirective,\r\n\r\n  MgformatMagicDirective,\r\n  DateMagicPipe,\r\n  TimeMagicPipe,\r\n  RangeValidatorMagicDirective,\r\n  NonMagicControlDirective,\r\n  MagicFocusDirective,\r\n  MagicViewContainerRef,\r\n  Time24MagicPipe\r\n\r\n\r\n];\r\n\r\n/**\r\n * @ignore\r\n */\r\n@NgModule({\r\n  declarations: [...decs],\r\n  exports     : [...decs,MaskitoModule],\r\n  entryComponents:[],\r\n  imports: [\r\n    CommonModule,\r\n    FormsModule,\r\n    ReactiveFormsModule,\r\n    RouterModule,\r\n    DynamicModule,\r\n    HttpClientModule\r\n  ],\r\n  //Customizable providers\r\n  providers:[ConfirmationComponentsMagicProvider, OverlayContainerMagicProvider]\r\n})\r\nexport class MagicModule {\r\n\r\n}\r\n"]}

package/esm2020/src/services/ISubformMagicService.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVN1YmZvcm1NYWdpY1NlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyL3NyYy9zZXJ2aWNlcy9JU3ViZm9ybU1hZ2ljU2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUm91dGVDb21tYW5kIH0gZnJvbSBcIi4vcm91dGVyLWNvbW1hbmRzLm1hZ2ljLnNlcnZpY2VcIjtcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSVN1YmZvcm1NYWdpY1NlcnZpY2V7XHJcbiAgRXhlY3V0ZVJvdXRlQ29tbWFuZChyb3V0ZUNvbW1hbmQ6IFJvdXRlQ29tbWFuZCk7XHJcbn1cclxuIl19