@eqproject/eqp-dynamic-module 2.8.8 → 3.0.1

package/esm2022/lib/directives/speech-to-text/speech-to-text.directive.mjs

@@ -0,0 +1,192 @@
+import { Directive, EventEmitter, HostListener, Input, Output, } from "@angular/core";
+import { interval } from "rxjs";
+import { GlobalService } from "../../services/global.service";
+import * as i0 from "@angular/core";
+/* ESEMPIO D'USO
+
+  <textarea
+    [(ngModel)]="text"
+  ></textarea>
+
+  <mat-icon
+    *ngIf="true" <!-- Senza NGIF non funziona -->
+    style="cursor: pointer; border-radius: 80px; padding: 5px;"
+    [SpeechToText]
+    [(bindedText)]="text"
+  >
+    keyboard_voice
+  </mat-icon>
+
+*/
+export class SpeechToTextDirective {
+    elementRef;
+    debug = false;
+    bindedText = "";
+    bindedTextChange = new EventEmitter();
+    beginSentence = "";
+    // bindedText = "";
+    domElement;
+    pausedClass = "keyboard_paused";
+    speakingClass = "keyboard_speaking";
+    recognition;
+    tempWords;
+    transcript_arr = [];
+    confidence_arr = [];
+    // isStarted = false; //<< this Flag to check if the user stop the service
+    isStoppedSpeechRecog = false;
+    isStoppedAutomatically = true; //<< this Flag to check if the service stopped automaticically.
+    timeInterval = interval(50);
+    subscription;
+    SpeechToggle() {
+        this.SpeechToTextToggler();
+    }
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.domElement = this.elementRef.nativeElement;
+        this.printDebug(window.navigator.userAgent);
+        try {
+            // questa operazione fallisce se non c'è webkit
+            this.recognition = new webkitSpeechRecognition();
+            this.printDebug(this.recognition);
+            this.recognition.continuous = true;
+            this.recognition.interimResults = true;
+            this.recognition.lang = "it-IT";
+            this.recognition.addEventListener("result", (e) => {
+                const transcript = Array.from(e.results)
+                    .map((result) => result[0])
+                    .map((result) => result.transcript)
+                    .join("");
+                this.printDebug("construcor transcript: " + transcript);
+                this.transcript_arr.push(transcript);
+                this.tempWords = transcript;
+                const confidence = Array.from(e.results)
+                    .map((result) => result[0])
+                    .map((result) => result.confidence)
+                    .join("");
+                this.confidence_arr.push(confidence);
+            });
+            this.recognition.addEventListener("end", (condition) => {
+                //this.wordConcat();
+                if (this.isStoppedAutomatically) {
+                    this.recognition.stop();
+                    this.recognition.start();
+                    this.isStoppedAutomatically = true;
+                }
+            });
+        }
+        catch (error) {
+            this.printDebug(error);
+            this.domElement.style.display = "none";
+        }
+    }
+    ngOnDestroy() {
+        this.printDebug("speech onDestroy");
+        if (this.recognition) {
+            this.recognition.abort();
+        }
+    }
+    SpeechToTextToggler() {
+        if (!GlobalService.isSpeechToTextStarted) {
+            this.printDebug("start");
+            this.beginSentence = this.bindedText;
+            if (this.bindedText == null ||
+                this.bindedText == undefined ||
+                this.bindedText == "") {
+                this.beginSentence = "";
+                this.bindedText = "";
+            }
+            this.transcript_arr = [];
+            this.confidence_arr = [];
+            let newtext = "";
+            this.start();
+            //this.isStillRecoginze = this.start() === true ? true : false;
+            this.subscription = this.timeInterval.subscribe((val) => {
+                if (this.bindedText == null || this.bindedText == undefined) {
+                    this.bindedText =
+                        this.beginSentence +
+                            this.transcript_arr[this.transcript_arr.length - 1];
+                    this.bindedTextChange.emit(this.bindedText);
+                }
+                else {
+                    newtext = this.transcript_arr[this.transcript_arr.length - 1];
+                    if (newtext != undefined) {
+                        this.bindedTextChange.emit(this.beginSentence + newtext);
+                        this.transcript_arr[this.transcript_arr.length - 1];
+                    }
+                    else {
+                        this.bindedTextChange.emit(this.bindedText);
+                    }
+                }
+            });
+        }
+        else {
+            if (GlobalService.speechDirective === this) {
+                this.printDebug("stop");
+                this.printDebug("binded: " + this.bindedText);
+                this.transcript_arr = [];
+                this.stop();
+                this.subscription.unsubscribe();
+            }
+            else {
+                this.printDebug("stop other");
+                GlobalService.speechDirective.SpeechToTextToggler();
+                let interval = setInterval(() => {
+                    if (GlobalService.speechDirective == null) {
+                        this.SpeechToTextToggler();
+                        clearInterval(interval);
+                    }
+                }, 100);
+            }
+        }
+    }
+    start() {
+        if (!GlobalService.isSpeechToTextStarted) {
+            this.elementRef.nativeElement.classList.remove(this.pausedClass);
+            this.elementRef.nativeElement.classList.add(this.speakingClass);
+            this.recognition.start();
+            GlobalService.isSpeechToTextStarted = true;
+            GlobalService.speechDirective = this;
+        }
+        return true;
+    }
+    stop() {
+        if (GlobalService.isSpeechToTextStarted) {
+            this.elementRef.nativeElement.classList.remove(this.speakingClass);
+            this.elementRef.nativeElement.classList.add(this.pausedClass);
+            this.isStoppedAutomatically = false;
+            this.wordConcat();
+            this.recognition.stop();
+            GlobalService.isSpeechToTextStarted = false;
+            GlobalService.speechDirective = null;
+            this.transcript_arr = [];
+        }
+        return false;
+    }
+    wordConcat() {
+        this.bindedText = this.bindedText + ". ";
+        // this.bindedText = this.bindedText + " " + this.tempWords + ".";
+        // this.tempWords = "";
+    }
+    printDebug(message) {
+        if (this.debug) {
+            console.log(message);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SpeechToTextDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: SpeechToTextDirective, selector: "[SpeechToText]", inputs: { bindedText: "bindedText" }, outputs: { bindedTextChange: "bindedTextChange" }, host: { listeners: { "click": "SpeechToggle()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SpeechToTextDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[SpeechToText]",
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { bindedText: [{
+                type: Input,
+                args: ["bindedText"]
+            }], bindedTextChange: [{
+                type: Output
+            }], SpeechToggle: [{
+                type: HostListener,
+                args: ["click"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"speech-to-text.directive.js","sourceRoot":"","sources":["../../../../../../projects/eqp-dynamic-module/src/lib/directives/speech-to-text/speech-to-text.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    Directive,\r\n    ElementRef,\r\n    EventEmitter,\r\n    HostListener,\r\n    Input,\r\n    OnDestroy,\r\n    Output,\r\n  } from \"@angular/core\";\r\n  import { interval, Subscription } from \"rxjs\";\r\n  import { GlobalService } from \"../../services/global.service\";\r\n  \r\n  declare var webkitSpeechRecognition: any;\r\n  \r\n  /* ESEMPIO D'USO\r\n  \r\n    <textarea\r\n      [(ngModel)]=\"text\"\r\n    ></textarea>\r\n  \r\n    <mat-icon\r\n      *ngIf=\"true\" <!-- Senza NGIF non funziona -->\r\n      style=\"cursor: pointer; border-radius: 80px; padding: 5px;\"\r\n      [SpeechToText]\r\n      [(bindedText)]=\"text\"\r\n    >\r\n      keyboard_voice\r\n    </mat-icon>\r\n  \r\n  */\r\n  \r\n  @Directive({\r\n    selector: \"[SpeechToText]\",\r\n  })\r\n  export class SpeechToTextDirective implements OnDestroy{\r\n  \r\n    debug = false;\r\n  \r\n    @Input(\"bindedText\") bindedText: string = \"\";\r\n    @Output() bindedTextChange: EventEmitter<string> = new EventEmitter<string>();\r\n    beginSentence: string = \"\";\r\n    // bindedText = \"\";\r\n    private domElement: HTMLElement;\r\n  \r\n    pausedClass: string = \"keyboard_paused\";\r\n    speakingClass: string = \"keyboard_speaking\";\r\n  \r\n    recognition;\r\n    tempWords: any;\r\n    transcript_arr = [];\r\n    confidence_arr = [];\r\n  \r\n    // isStarted = false; //<< this Flag to check if the user stop the service\r\n    isStoppedSpeechRecog = false;\r\n    isStoppedAutomatically = true; //<< this Flag to check if the service stopped automaticically.\r\n  \r\n    timeInterval = interval(50);\r\n    subscription: Subscription;\r\n  \r\n    @HostListener(\"click\") SpeechToggle() {\r\n      this.SpeechToTextToggler();\r\n    }\r\n  \r\n    constructor(\r\n      private elementRef: ElementRef\r\n      ) {\r\n  \r\n      this.domElement = this.elementRef.nativeElement as HTMLElement;\r\n    \r\n      this.printDebug(window.navigator.userAgent);\r\n  \r\n      try {\r\n        // questa operazione fallisce se non c'è webkit\r\n        this.recognition = new webkitSpeechRecognition();\r\n  \r\n        this.printDebug(this.recognition);\r\n  \r\n        this.recognition.continuous = true;\r\n        this.recognition.interimResults = true;\r\n        this.recognition.lang = \"it-IT\";\r\n  \r\n        this.recognition.addEventListener(\"result\", (e: any) => {\r\n          const transcript = Array.from(e.results)\r\n            .map((result: any) => result[0])\r\n            .map((result) => result.transcript)\r\n            .join(\"\");\r\n  \r\n          this.printDebug(\"construcor transcript: \" + transcript);\r\n  \r\n  \r\n          this.transcript_arr.push(transcript);\r\n          this.tempWords = transcript;\r\n  \r\n          const confidence = Array.from(e.results)\r\n            .map((result: any) => result[0])\r\n            .map((result) => result.confidence)\r\n            .join(\"\");\r\n          this.confidence_arr.push(confidence);\r\n        });\r\n  \r\n        this.recognition.addEventListener(\"end\", (condition: any) => {\r\n          //this.wordConcat();\r\n          if (this.isStoppedAutomatically) {\r\n            this.recognition.stop();\r\n            this.recognition.start();\r\n            this.isStoppedAutomatically = true;\r\n          }\r\n        });\r\n      } catch (error) {\r\n  \r\n        this.printDebug(error);\r\n  \r\n        this.domElement.style.display = \"none\";\r\n      }\r\n  \r\n    }\r\n  \r\n    ngOnDestroy(): void {\r\n      this.printDebug(\"speech onDestroy\");\r\n      \r\n      if(this.recognition){\r\n        this.recognition.abort();\r\n      }\r\n    }\r\n  \r\n    SpeechToTextToggler() {\r\n      if (!GlobalService.isSpeechToTextStarted) {\r\n  \r\n        this.printDebug(\"start\");\r\n  \r\n        this.beginSentence = this.bindedText;\r\n        if (\r\n          this.bindedText == null ||\r\n          this.bindedText == undefined ||\r\n          this.bindedText == \"\"\r\n        ) {\r\n          this.beginSentence = \"\";\r\n          this.bindedText = \"\";\r\n        }\r\n        this.transcript_arr = [];\r\n        this.confidence_arr = [];\r\n  \r\n        let newtext = \"\";\r\n        this.start();\r\n        //this.isStillRecoginze = this.start() === true ? true : false;\r\n        this.subscription = this.timeInterval.subscribe((val) => {\r\n          if (this.bindedText == null || this.bindedText == undefined) {\r\n            this.bindedText =\r\n              this.beginSentence +\r\n              this.transcript_arr[this.transcript_arr.length - 1];\r\n            this.bindedTextChange.emit(this.bindedText);\r\n          } else {\r\n            newtext = this.transcript_arr[this.transcript_arr.length - 1];\r\n            if (newtext != undefined) {\r\n              this.bindedTextChange.emit(this.beginSentence + newtext);\r\n              this.transcript_arr[this.transcript_arr.length - 1];\r\n            } else {\r\n              this.bindedTextChange.emit(this.bindedText);\r\n            }\r\n          }\r\n        });\r\n      } else {\r\n        if(GlobalService.speechDirective === this){\r\n          this.printDebug(\"stop\");\r\n          this.printDebug(\"binded: \" + this.bindedText);\r\n    \r\n          this.transcript_arr = [];\r\n          this.stop();\r\n          this.subscription.unsubscribe();\r\n        } else {\r\n          this.printDebug(\"stop other\");\r\n          GlobalService.speechDirective.SpeechToTextToggler();\r\n          let interval = setInterval(() => {\r\n            if(GlobalService.speechDirective == null){\r\n              this.SpeechToTextToggler();\r\n              clearInterval(interval)\r\n            }\r\n          }, 100);\r\n        }\r\n      }\r\n    }\r\n  \r\n    private start() {\r\n      if (!GlobalService.isSpeechToTextStarted) {\r\n        this.elementRef.nativeElement.classList.remove(this.pausedClass);\r\n        this.elementRef.nativeElement.classList.add(this.speakingClass);\r\n        this.recognition.start();\r\n        GlobalService.isSpeechToTextStarted = true;\r\n        GlobalService.speechDirective = this;\r\n      }\r\n      return true;\r\n    }\r\n    private stop() {    \r\n      if (GlobalService.isSpeechToTextStarted) {\r\n        this.elementRef.nativeElement.classList.remove(this.speakingClass);\r\n        this.elementRef.nativeElement.classList.add(this.pausedClass);\r\n        this.isStoppedAutomatically = false;\r\n        this.wordConcat();\r\n        this.recognition.stop();\r\n        GlobalService.isSpeechToTextStarted = false;\r\n        GlobalService.speechDirective = null;\r\n        this.transcript_arr = [];\r\n      }\r\n      return false;\r\n    }\r\n  \r\n    private wordConcat() {\r\n      this.bindedText = this.bindedText + \". \";\r\n      // this.bindedText = this.bindedText + \" \" + this.tempWords + \".\";\r\n      // this.tempWords = \"\";\r\n    }\r\n  \r\n    private printDebug(message){\r\n      if(this.debug){\r\n        console.log(message);\r\n      }\r\n    }\r\n  }\r\n  "]}

package/esm2022/lib/eqp-dynamic-module.module.mjs

@@ -0,0 +1,253 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { EqpDynamicModuleComponent } from './components/exported/eqp-dynamic-module/eqp-dynamic-module.component';
+import { MaterialModule } from './modules/material.module';
+import { EqpTableModule } from '@eqproject/eqp-table';
+import { EqpAttachmentsModule } from '@eqproject/eqp-attachments';
+import { EqpSelectModule } from '@eqproject/eqp-select';
+import { EqpDatetimerangepickerModule } from '@eqproject/eqp-datetimerangepicker';
+import { EqpFiltersModule } from '@eqproject/eqp-filters';
+import { EqpNumericInputMode, EqpNumericModule } from '@eqproject/eqp-numeric';
+import { EqpDynamicModuleConfiguratorComponent } from './components/exported/eqp-dynamic-module-configurator/eqp-dynamic-module-configurator.component';
+import { AddFormFieldComponent } from './components/private/add-form-field/add-form-field.component';
+import { TextFieldTemplateComponent } from './components/private/field-templates/text-field-template/text-field-template.component';
+import { BooleanFieldTemplateComponent } from './components/private/field-templates/boolean-field-template/boolean-field-template.component';
+import { DateFieldTemplateComponent } from './components/private/field-templates/date-field-template/date-field-template.component';
+import { TextareaFieldTemplateComponent } from './components/private/field-templates/textarea-field-template/textarea-field-template.component';
+import { NumericFieldTemplateComponent } from './components/private/field-templates/numeric-field-template/numeric-field-template.component';
+import { ListValueFieldTemplateComponent } from './components/private/field-templates/list-value-field-template/list-value-field-template.component';
+import { AttachmentFieldTemplateComponent } from './components/private/field-templates/attachment-field-template/attachment-field-template.component';
+import { ImageFieldTemplateComponent } from './components/private/field-templates/image-field-template/image-field-template.component';
+import { ListFormRecordComponent } from './components/private/form-records/list-form-record/list-form-record.component';
+import { AddFormRecordComponent } from './components/private/form-records/add-form-record/add-form-record.component';
+import { SpinnerComponent } from './components/private/spinner/spinner.component';
+import { DynamicModuleFieldFixComponent } from './components/private/dynamic-module-field-fix/dynamic-module-field.component';
+import { AddFormulaComponent, DialogDataExampleDialog } from './components/private/add-formula-field/add-formula-field.component';
+import { RepairFormFieldsComponent } from './components/private/form-records/repair-form-fields/repair-form-fields.component';
+import { ListViewFormRecordComponent } from './components/private/form-records/list-view-form-record/list-view-form-record.component';
+import { ViewFormRecordComponent } from './components/private/form-records/view-form-record/view-form-record.component';
+import { SingleRecordComponent } from './components/private/form-records/list-view-form-record/single-record/single-record.component';
+import { FilterFormStatisticComponent } from './components/private/form-statistics/filter-form-statistic/filter-form-statistic.component';
+import { DynamicModuleFilterFixComponent } from './components/private/form-statistics/dynamic-module-filter-fix/dynamic-module-filter-fix.component';
+import { TextFilterTemplateComponent } from './components/private/form-statistics/filter-templates/text-filter-template/text-filter-template.component';
+import { NumericFilterTemplateComponent } from './components/private/form-statistics/filter-templates/numeric-filter-template/numeric-filter-template.component';
+import { BooleanFilterTemplateComponent } from './components/private/form-statistics/filter-templates/boolean-filter-template/boolean-filter-template.component';
+import { DateFilterTemplateComponent } from './components/private/form-statistics/filter-templates/date-filter-template/date-filter-template.component';
+import { ListValueFilterTemplateComponent } from './components/private/form-statistics/filter-templates/list-value-filter-template/list-value-filter-template.component';
+import { TextareaFilterTemplateComponent } from './components/private/form-statistics/filter-templates/textarea-filter-template/textarea-filter-template.component';
+import { AttachmentFilterTemplateComponent } from './components/private/form-statistics/filter-templates/attachment-filter-template/attachment-filter-template.component';
+import { ImageFilterTemplateComponent } from './components/private/form-statistics/filter-templates/image-filter-template/image-filter-template.component';
+import { ListFormRecordFilterTemplateComponent } from './components/private/form-statistics/filter-templates/list-form-record-filter-template/list-form-record-filter-template.component';
+import { GraphsComponent } from './components/private/graphs/graphs.component';
+import { GraphComponent } from './components/private/graphs/graph/graph.component';
+import { CanvasJSAngularStockChartsModule, CanvasJSChart, CanvasJSStockChart } from '@canvasjs/angular-stockcharts';
+import { ImageFieldSelectorTemplateComponent } from './components/private/field-templates/image-field-selector-template/image-field-selector-template.component';
+import { LabelFieldTemplateComponent } from './components/private/field-templates/label-field-template/label-field-template.component';
+import { ImageSelectorFilterTemplateComponent } from './components/private/form-statistics/filter-templates/image-selector-filter-template/image-selector-filter-template.component';
+import { EqpImgDrawingModule } from '@eqproject/eqp-img-drawing';
+import { TmwImageDrawerComponent } from './components/private/tmw-image-drawer/tmw-image-drawer.component';
+import { ImageWithMarkersFieldTemplateComponent } from './components/private/field-templates/image-with-markers-field-template/image-with-markers-field-template.component';
+import { TmwImageMarkerComponent } from './components/private/tmw-image-marker/tmw-image-marker.component';
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { DynamicLoaderDirective } from './directives/dynamic-loader/dynamic-loader.directive';
+import { DbgetterComponent } from './components/private/dbgetter/dbgetter.component';
+import { TmwPickerModule } from "tmw-picker";
+import { TriggerCreatorComponent } from './components/private/trigger-creator/trigger-creator.component';
+import { DynamicModuleTriggerFixComponent } from './components/private/trigger-creator/dynamic-module-trigger-fix/dynamic-module-trigger-fix.component';
+import { TextTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/text-trigger-template/text-trigger-template.component';
+import { NumericTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/numeric-trigger-template/numeric-trigger-template.component';
+import { BooleanTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/boolean-trigger-template/boolean-trigger-template.component';
+import { DateTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/date-trigger-template/date-trigger-template.component';
+import { ListValueTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/list-value-trigger-template/list-value-trigger-template.component';
+import { TextareaTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/textarea-trigger-template/textarea-trigger-template.component';
+import { ListFormRecordTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/list-form-record-trigger-template/list-form-record-trigger-template.component';
+import { SpeechToTextDirective } from './directives/speech-to-text/speech-to-text.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@eqproject/eqp-numeric";
+export const customNumericMaskConfig = {
+    align: "right",
+    allowNegative: true,
+    allowZero: true,
+    decimal: "",
+    precision: 0,
+    prefix: "",
+    suffix: "",
+    thousands: "",
+    nullable: true,
+    min: null,
+    max: null,
+    inputMode: EqpNumericInputMode.FINANCIAL,
+};
+export class EqpDynamicModuleModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EqpDynamicModuleModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: EqpDynamicModuleModule, declarations: [EqpDynamicModuleComponent,
+            EqpDynamicModuleConfiguratorComponent,
+            AddFormFieldComponent,
+            TextFieldTemplateComponent,
+            BooleanFieldTemplateComponent,
+            DateFieldTemplateComponent,
+            TextareaFieldTemplateComponent,
+            NumericFieldTemplateComponent,
+            ListValueFieldTemplateComponent,
+            AttachmentFieldTemplateComponent,
+            ImageFieldTemplateComponent,
+            ListFormRecordComponent,
+            ListViewFormRecordComponent,
+            AddFormRecordComponent,
+            ViewFormRecordComponent,
+            DynamicModuleFieldFixComponent,
+            SpinnerComponent,
+            AddFormulaComponent,
+            DialogDataExampleDialog,
+            RepairFormFieldsComponent,
+            SingleRecordComponent,
+            FilterFormStatisticComponent,
+            DynamicModuleFilterFixComponent,
+            DynamicModuleTriggerFixComponent,
+            TextFilterTemplateComponent,
+            NumericFilterTemplateComponent,
+            BooleanFilterTemplateComponent,
+            DateFilterTemplateComponent,
+            ListValueFilterTemplateComponent,
+            TextareaFilterTemplateComponent,
+            AttachmentFilterTemplateComponent,
+            ImageFilterTemplateComponent,
+            ListFormRecordFilterTemplateComponent,
+            GraphsComponent,
+            GraphComponent,
+            ImageFieldSelectorTemplateComponent,
+            LabelFieldTemplateComponent,
+            ImageSelectorFilterTemplateComponent,
+            TmwImageDrawerComponent,
+            ImageWithMarkersFieldTemplateComponent,
+            TmwImageMarkerComponent,
+            DynamicLoaderDirective,
+            DbgetterComponent,
+            TriggerCreatorComponent,
+            TextTriggerTemplateComponent,
+            NumericTriggerTemplateComponent,
+            BooleanTriggerTemplateComponent,
+            DateTriggerTemplateComponent,
+            ListValueTriggerTemplateComponent,
+            TextareaTriggerTemplateComponent,
+            ListFormRecordTriggerTemplateComponent,
+            SpeechToTextDirective], imports: [MaterialModule,
+            FormsModule,
+            CommonModule,
+            ReactiveFormsModule,
+            EqpTableModule,
+            EqpAttachmentsModule,
+            EqpSelectModule,
+            EqpDatetimerangepickerModule,
+            EqpFiltersModule,
+            EqpImgDrawingModule,
+            DragDropModule, i1.EqpNumericModule, CanvasJSAngularStockChartsModule,
+            TmwPickerModule], exports: [EqpDynamicModuleComponent,
+            EqpDynamicModuleConfiguratorComponent,
+            DragDropModule,
+            CanvasJSChart,
+            CanvasJSStockChart,
+            DynamicLoaderDirective,
+            TmwPickerModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EqpDynamicModuleModule, imports: [MaterialModule,
+            FormsModule,
+            CommonModule,
+            ReactiveFormsModule,
+            EqpTableModule,
+            EqpAttachmentsModule,
+            EqpSelectModule,
+            EqpDatetimerangepickerModule,
+            EqpFiltersModule,
+            EqpImgDrawingModule,
+            DragDropModule,
+            EqpNumericModule.forRoot(customNumericMaskConfig),
+            CanvasJSAngularStockChartsModule,
+            TmwPickerModule, DragDropModule,
+            TmwPickerModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EqpDynamicModuleModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        EqpDynamicModuleComponent,
+                        EqpDynamicModuleConfiguratorComponent,
+                        AddFormFieldComponent,
+                        TextFieldTemplateComponent,
+                        BooleanFieldTemplateComponent,
+                        DateFieldTemplateComponent,
+                        TextareaFieldTemplateComponent,
+                        NumericFieldTemplateComponent,
+                        ListValueFieldTemplateComponent,
+                        AttachmentFieldTemplateComponent,
+                        ImageFieldTemplateComponent,
+                        ListFormRecordComponent,
+                        ListViewFormRecordComponent,
+                        AddFormRecordComponent,
+                        ViewFormRecordComponent,
+                        DynamicModuleFieldFixComponent,
+                        SpinnerComponent,
+                        AddFormulaComponent,
+                        DialogDataExampleDialog,
+                        RepairFormFieldsComponent,
+                        SingleRecordComponent,
+                        FilterFormStatisticComponent,
+                        DynamicModuleFilterFixComponent,
+                        DynamicModuleTriggerFixComponent,
+                        TextFilterTemplateComponent,
+                        NumericFilterTemplateComponent,
+                        BooleanFilterTemplateComponent,
+                        DateFilterTemplateComponent,
+                        ListValueFilterTemplateComponent,
+                        TextareaFilterTemplateComponent,
+                        AttachmentFilterTemplateComponent,
+                        ImageFilterTemplateComponent,
+                        ListFormRecordFilterTemplateComponent,
+                        GraphsComponent,
+                        GraphComponent,
+                        ImageFieldSelectorTemplateComponent,
+                        LabelFieldTemplateComponent,
+                        ImageSelectorFilterTemplateComponent,
+                        TmwImageDrawerComponent,
+                        ImageWithMarkersFieldTemplateComponent,
+                        TmwImageMarkerComponent,
+                        DynamicLoaderDirective,
+                        DbgetterComponent,
+                        TriggerCreatorComponent,
+                        TextTriggerTemplateComponent,
+                        NumericTriggerTemplateComponent,
+                        BooleanTriggerTemplateComponent,
+                        DateTriggerTemplateComponent,
+                        ListValueTriggerTemplateComponent,
+                        TextareaTriggerTemplateComponent,
+                        ListFormRecordTriggerTemplateComponent,
+                        SpeechToTextDirective
+                    ],
+                    imports: [
+                        MaterialModule,
+                        FormsModule,
+                        CommonModule,
+                        ReactiveFormsModule,
+                        EqpTableModule,
+                        EqpAttachmentsModule,
+                        EqpSelectModule,
+                        EqpDatetimerangepickerModule,
+                        EqpFiltersModule,
+                        EqpImgDrawingModule,
+                        DragDropModule,
+                        EqpNumericModule.forRoot(customNumericMaskConfig),
+                        CanvasJSAngularStockChartsModule,
+                        TmwPickerModule
+                    ],
+                    exports: [
+                        EqpDynamicModuleComponent,
+                        EqpDynamicModuleConfiguratorComponent,
+                        DragDropModule,
+                        CanvasJSChart,
+                        CanvasJSStockChart,
+                        DynamicLoaderDirective,
+                        TmwPickerModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eqp-dynamic-module.module.js","sourceRoot":"","sources":["../../../../projects/eqp-dynamic-module/src/lib/eqp-dynamic-module.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\r\nimport { NgModule } from '@angular/core';\r\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\r\nimport { EqpDynamicModuleComponent } from './components/exported/eqp-dynamic-module/eqp-dynamic-module.component';\r\nimport { MaterialModule } from './modules/material.module';\r\nimport { EqpTableModule } from '@eqproject/eqp-table';\r\nimport { EqpAttachmentsModule } from '@eqproject/eqp-attachments';\r\nimport { EqpSelectModule } from '@eqproject/eqp-select';\r\nimport { EqpDatetimerangepickerModule } from '@eqproject/eqp-datetimerangepicker';\r\nimport { EqpFiltersModule } from '@eqproject/eqp-filters';\r\nimport { EqpNumericInputMode, EqpNumericModule } from '@eqproject/eqp-numeric';\r\nimport { EqpDynamicModuleConfiguratorComponent } from './components/exported/eqp-dynamic-module-configurator/eqp-dynamic-module-configurator.component';\r\nimport { AddFormFieldComponent } from './components/private/add-form-field/add-form-field.component';\r\nimport { TextFieldTemplateComponent } from './components/private/field-templates/text-field-template/text-field-template.component';\r\nimport { BooleanFieldTemplateComponent } from './components/private/field-templates/boolean-field-template/boolean-field-template.component';\r\nimport { DateFieldTemplateComponent } from './components/private/field-templates/date-field-template/date-field-template.component';\r\nimport { TextareaFieldTemplateComponent } from './components/private/field-templates/textarea-field-template/textarea-field-template.component';\r\nimport { NumericFieldTemplateComponent } from './components/private/field-templates/numeric-field-template/numeric-field-template.component';\r\nimport { ListValueFieldTemplateComponent } from './components/private/field-templates/list-value-field-template/list-value-field-template.component';\r\nimport { AttachmentFieldTemplateComponent } from './components/private/field-templates/attachment-field-template/attachment-field-template.component';\r\nimport { ImageFieldTemplateComponent } from './components/private/field-templates/image-field-template/image-field-template.component';\r\nimport { ListFormRecordComponent } from './components/private/form-records/list-form-record/list-form-record.component';\r\nimport { AddFormRecordComponent } from './components/private/form-records/add-form-record/add-form-record.component';\r\nimport { SpinnerComponent } from './components/private/spinner/spinner.component';\r\nimport { DynamicModuleFieldFixComponent } from './components/private/dynamic-module-field-fix/dynamic-module-field.component';\r\nimport { AddFormulaComponent,DialogDataExampleDialog } from './components/private/add-formula-field/add-formula-field.component';\r\nimport { RepairFormFieldsComponent } from './components/private/form-records/repair-form-fields/repair-form-fields.component';\r\nimport { ListViewFormRecordComponent } from './components/private/form-records/list-view-form-record/list-view-form-record.component';\r\nimport { ViewFormRecordComponent } from './components/private/form-records/view-form-record/view-form-record.component';\r\nimport { SingleRecordComponent } from './components/private/form-records/list-view-form-record/single-record/single-record.component';\r\nimport { FilterFormStatisticComponent } from './components/private/form-statistics/filter-form-statistic/filter-form-statistic.component';\r\nimport { DynamicModuleFilterFixComponent } from './components/private/form-statistics/dynamic-module-filter-fix/dynamic-module-filter-fix.component';\r\nimport { TextFilterTemplateComponent } from './components/private/form-statistics/filter-templates/text-filter-template/text-filter-template.component';\r\nimport { NumericFilterTemplateComponent } from './components/private/form-statistics/filter-templates/numeric-filter-template/numeric-filter-template.component';\r\nimport { BooleanFilterTemplateComponent } from './components/private/form-statistics/filter-templates/boolean-filter-template/boolean-filter-template.component';\r\nimport { DateFilterTemplateComponent } from './components/private/form-statistics/filter-templates/date-filter-template/date-filter-template.component';\r\nimport { ListValueFilterTemplateComponent } from './components/private/form-statistics/filter-templates/list-value-filter-template/list-value-filter-template.component';\r\nimport { TextareaFilterTemplateComponent } from './components/private/form-statistics/filter-templates/textarea-filter-template/textarea-filter-template.component';\r\nimport { AttachmentFilterTemplateComponent } from './components/private/form-statistics/filter-templates/attachment-filter-template/attachment-filter-template.component';\r\nimport { ImageFilterTemplateComponent } from './components/private/form-statistics/filter-templates/image-filter-template/image-filter-template.component';\r\nimport { ListFormRecordFilterTemplateComponent } from './components/private/form-statistics/filter-templates/list-form-record-filter-template/list-form-record-filter-template.component';\r\nimport { GraphsComponent } from './components/private/graphs/graphs.component';\r\nimport { GraphComponent } from './components/private/graphs/graph/graph.component';\r\nimport { CanvasJSAngularStockChartsModule, CanvasJSChart, CanvasJSStockChart } from '@canvasjs/angular-stockcharts';\r\nimport { ImageFieldSelectorTemplateComponent } from './components/private/field-templates/image-field-selector-template/image-field-selector-template.component';\r\nimport { LabelFieldTemplateComponent } from './components/private/field-templates/label-field-template/label-field-template.component';\r\nimport { ImageSelectorFilterTemplateComponent } from './components/private/form-statistics/filter-templates/image-selector-filter-template/image-selector-filter-template.component';\r\nimport { EqpImgDrawingModule } from '@eqproject/eqp-img-drawing';\r\nimport { TmwImageDrawerComponent } from './components/private/tmw-image-drawer/tmw-image-drawer.component';\r\nimport { ImageWithMarkersFieldTemplateComponent } from './components/private/field-templates/image-with-markers-field-template/image-with-markers-field-template.component';\r\nimport { TmwImageMarkerComponent } from './components/private/tmw-image-marker/tmw-image-marker.component';\r\nimport { DragDropModule } from '@angular/cdk/drag-drop';\r\nimport { DynamicLoaderDirective } from './directives/dynamic-loader/dynamic-loader.directive';\r\nimport { DbgetterComponent } from './components/private/dbgetter/dbgetter.component';\r\nimport {TmwPickerModule} from \"tmw-picker\";\r\nimport { TriggerCreatorComponent } from './components/private/trigger-creator/trigger-creator.component';\r\nimport { DynamicModuleTriggerFixComponent } from './components/private/trigger-creator/dynamic-module-trigger-fix/dynamic-module-trigger-fix.component';\r\nimport { TextTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/text-trigger-template/text-trigger-template.component';\r\nimport { NumericTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/numeric-trigger-template/numeric-trigger-template.component';\r\nimport { BooleanTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/boolean-trigger-template/boolean-trigger-template.component';\r\nimport { DateTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/date-trigger-template/date-trigger-template.component';\r\nimport { ListValueTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/list-value-trigger-template/list-value-trigger-template.component';\r\nimport { TextareaTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/textarea-trigger-template/textarea-trigger-template.component';\r\nimport { ListFormRecordTriggerTemplateComponent } from './components/private/trigger-creator/trigger-templates/list-form-record-trigger-template/list-form-record-trigger-template.component';\r\nimport { SpeechToTextDirective } from './directives/speech-to-text/speech-to-text.directive';\r\n\r\nexport const customNumericMaskConfig = {\r\n  align: \"right\",\r\n  allowNegative: true,\r\n  allowZero: true,\r\n  decimal: \"\",\r\n  precision: 0,\r\n  prefix: \"\",\r\n  suffix: \"\",\r\n  thousands: \"\",\r\n  nullable: true,\r\n  min: null,\r\n  max: null,\r\n  inputMode: EqpNumericInputMode.FINANCIAL,\r\n};\r\n\r\n@NgModule({\r\n  declarations: [\r\n    EqpDynamicModuleComponent,\r\n    EqpDynamicModuleConfiguratorComponent,\r\n    AddFormFieldComponent,\r\n    TextFieldTemplateComponent,\r\n    BooleanFieldTemplateComponent,\r\n    DateFieldTemplateComponent,\r\n    TextareaFieldTemplateComponent,\r\n    NumericFieldTemplateComponent,\r\n    ListValueFieldTemplateComponent,\r\n    AttachmentFieldTemplateComponent,\r\n    ImageFieldTemplateComponent,\r\n    ListFormRecordComponent,\r\n    ListViewFormRecordComponent,\r\n    AddFormRecordComponent,\r\n    ViewFormRecordComponent,\r\n    DynamicModuleFieldFixComponent,\r\n    SpinnerComponent,\r\n    AddFormulaComponent,\r\n    DialogDataExampleDialog,\r\n    RepairFormFieldsComponent,\r\n    SingleRecordComponent,\r\n    FilterFormStatisticComponent,\r\n    DynamicModuleFilterFixComponent,\r\n    DynamicModuleTriggerFixComponent,\r\n    TextFilterTemplateComponent,\r\n    NumericFilterTemplateComponent,\r\n    BooleanFilterTemplateComponent,\r\n    DateFilterTemplateComponent,\r\n    ListValueFilterTemplateComponent,\r\n    TextareaFilterTemplateComponent,\r\n    AttachmentFilterTemplateComponent,\r\n    ImageFilterTemplateComponent,\r\n    ListFormRecordFilterTemplateComponent,\r\n    GraphsComponent,\r\n    GraphComponent,\r\n    ImageFieldSelectorTemplateComponent,\r\n    LabelFieldTemplateComponent,\r\n    ImageSelectorFilterTemplateComponent,\r\n    TmwImageDrawerComponent,\r\n    ImageWithMarkersFieldTemplateComponent,\r\n    TmwImageMarkerComponent,\r\n    DynamicLoaderDirective,\r\n    DbgetterComponent,\r\n    TriggerCreatorComponent,\r\n    TextTriggerTemplateComponent,\r\n    NumericTriggerTemplateComponent,\r\n    BooleanTriggerTemplateComponent,\r\n    DateTriggerTemplateComponent,\r\n    ListValueTriggerTemplateComponent,\r\n    TextareaTriggerTemplateComponent,\r\n    ListFormRecordTriggerTemplateComponent,\r\n    SpeechToTextDirective\r\n\r\n  ],\r\n  imports: [\r\n    MaterialModule,\r\n    FormsModule,\r\n    CommonModule,\r\n    ReactiveFormsModule,\r\n    EqpTableModule,\r\n    EqpAttachmentsModule,\r\n    EqpSelectModule,\r\n    EqpDatetimerangepickerModule,\r\n    EqpFiltersModule,\r\n    EqpImgDrawingModule,\r\n    DragDropModule,\r\n    EqpNumericModule.forRoot(customNumericMaskConfig),\r\n    CanvasJSAngularStockChartsModule,\r\n    TmwPickerModule\r\n  ],\r\n  exports: [\r\n    EqpDynamicModuleComponent,\r\n    EqpDynamicModuleConfiguratorComponent,\r\n    DragDropModule,\r\n    CanvasJSChart,\r\n    CanvasJSStockChart,\r\n    DynamicLoaderDirective,\r\n    TmwPickerModule\r\n  ]\r\n})\r\nexport class EqpDynamicModuleModule { }\r\n"]}

package/{esm2020 → esm2022}/lib/interfaces/iBaseFieldComponent.interface.mjs

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

package/{esm2020 → esm2022}/lib/interfaces/iRootObject.interface.mjs

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