@bnsights/bbsf-controls 1.0.149 → 1.0.151

package/README.md

@@ -5,6 +5,14 @@ BBSF Controls package is part of BBSF 3 packages. It has all the form controls t
 For more info please visit [BBSF Controls documenation](https://bbsfadmin.bnsights.com/controls) or [BBSF documentation](https://bnsightsprojects.visualstudio.com/BBSF%203/_wiki/wikis/BBSF-3.wiki/65/BBSF-Documentation)
 
 # Change Log
+## 1.0.151 / 19-8-2024
+======================
+* Added MarkdownEditor Control
+
+## 1.0.150 / 8-8-2024
+======================
+* Updated TextAreaComponent speech language select with UI fixes
+
 ## 1.0.149 / 6-8-2024
 ======================
 * Updated TextAreaComponent speech language select

package/esm2022/lib/Shared/Enums/Markdown.mjs

@@ -0,0 +1,20 @@
+export var MarkdownMode;
+(function (MarkdownMode) {
+    MarkdownMode["editor"] = "editor";
+    MarkdownMode["preview"] = "preview";
+})(MarkdownMode || (MarkdownMode = {}));
+export var MarkDownIcons;
+(function (MarkDownIcons) {
+    MarkDownIcons["Bold"] = "Bold";
+    MarkDownIcons["Italic"] = "Italic";
+    MarkDownIcons["Heading"] = "Heading";
+    MarkDownIcons["Reference"] = "Reference";
+    MarkDownIcons["Link"] = "Link";
+    MarkDownIcons["Image"] = "Image";
+    MarkDownIcons["Ul"] = "Ul";
+    MarkDownIcons["Ol"] = "Ol";
+    MarkDownIcons["Code"] = "Code";
+    MarkDownIcons["TogglePreview"] = "TogglePreview";
+    MarkDownIcons["FullScreen"] = "FullScreen";
+})(MarkDownIcons || (MarkDownIcons = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWFya2Rvd24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9iYnNmLWNvbnRyb2xzL3NyYy9saWIvU2hhcmVkL0VudW1zL01hcmtkb3duLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFlBR1Q7QUFISCxXQUFZLFlBQVk7SUFDcEIsaUNBQWUsQ0FBQTtJQUNmLG1DQUFpQixDQUFBO0FBQ25CLENBQUMsRUFIUyxZQUFZLEtBQVosWUFBWSxRQUdyQjtBQUNELE1BQU0sQ0FBTixJQUFZLGFBWVg7QUFaRCxXQUFZLGFBQWE7SUFDdkIsOEJBQWEsQ0FBQTtJQUNiLGtDQUFpQixDQUFBO0lBQ2pCLG9DQUFtQixDQUFBO0lBQ25CLHdDQUF1QixDQUFBO0lBQ3ZCLDhCQUFhLENBQUE7SUFDYixnQ0FBZSxDQUFBO0lBQ2YsMEJBQVMsQ0FBQTtJQUNULDBCQUFTLENBQUE7SUFDVCw4QkFBYSxDQUFBO0lBQ2IsZ0RBQStCLENBQUE7SUFDL0IsMENBQXlCLENBQUE7QUFDM0IsQ0FBQyxFQVpXLGFBQWEsS0FBYixhQUFhLFFBWXhCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gTWFya2Rvd25Nb2RlIHtcclxuICAgIGVkaXRvcj1cImVkaXRvclwiLFxyXG4gICAgcHJldmlldz1cInByZXZpZXdcIlxyXG4gIH1cclxuICBleHBvcnQgZW51bSBNYXJrRG93bkljb25zIHtcclxuICAgIEJvbGQgPSAnQm9sZCcsXHJcbiAgICBJdGFsaWMgPSAnSXRhbGljJyxcclxuICAgIEhlYWRpbmcgPSAnSGVhZGluZycsXHJcbiAgICBSZWZlcmVuY2UgPSAnUmVmZXJlbmNlJyxcclxuICAgIExpbmsgPSAnTGluaycsXHJcbiAgICBJbWFnZSA9ICdJbWFnZScsXHJcbiAgICBVbCA9ICdVbCcsXHJcbiAgICBPbCA9ICdPbCcsXHJcbiAgICBDb2RlID0gJ0NvZGUnLFxyXG4gICAgVG9nZ2xlUHJldmlldyA9ICdUb2dnbGVQcmV2aWV3JyxcclxuICAgIEZ1bGxTY3JlZW4gPSAnRnVsbFNjcmVlbidcclxuICB9XHJcbiAgXHJcbiAgIl19

package/esm2022/lib/Shared/Models/MarkdownEditorOptions.mjs

@@ -0,0 +1,24 @@
+import { ControlOptionsBase } from "./ControlOptionsBase";
+export class MarkdownEditorOptions extends ControlOptionsBase {
+    constructor() {
+        super(...arguments);
+        /**To set  value  to MarkdownEditor */
+        this.value = '';
+        //Enable viewing preview panel
+        this.showPreviewPanelOnLoad = true;
+        /**
+         * Array of icons to be hidden from the toolbar.
+         *
+         * You can populate this array with icon names from the `MarkDownIcons` enum.
+         * This allows you to customize the toolbar by hiding specific icons based on your requirements.
+         *
+         * @example
+         * // Hide the Bold and Italic icons
+         * hideIcons: [MarkDownIcons.Bold, MarkDownIcons.Italic];
+         */
+        this.hideIcons = [];
+        /** Set Height For MarkdownEditor ,default=400px */
+        this.height = '400px';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/controls/MarkdownEditor/markdown-editor.component.mjs

@@ -0,0 +1,235 @@
+import { Component, EventEmitter, Input, Optional, Output } from '@angular/core';
+import { FormControl, Validators } from '@angular/forms';
+import { MarkdownMode } from '../../Shared/Enums/Markdown';
+import { switchMap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@bnsights/bbsf-utilities";
+import * as i2 from "../../Shared/services/GlobalSettings.service";
+import * as i3 from "../../Shared/services/ControlUtility";
+import * as i4 from "@angular/forms";
+import * as i5 from "ngx-script-loader";
+import * as i6 from "@angular/common";
+import * as i7 from "ngx-intl-tel-input";
+import * as i8 from "ngx-markdown-editor";
+export class MarkdownEditorComponent {
+    static { this.controlContainerstatic = null; }
+    constructor(utilityService, globalSettings, controlValidationService, controlUtility, markdownEditorControlHost, scriptService, controlContainer) {
+        this.utilityService = utilityService;
+        this.globalSettings = globalSettings;
+        this.controlValidationService = controlValidationService;
+        this.controlUtility = controlUtility;
+        this.markdownEditorControlHost = markdownEditorControlHost;
+        this.scriptService = scriptService;
+        this.controlContainer = controlContainer;
+        this.OnChange = new EventEmitter();
+        this.hideToolbar = false;
+        this.validationRules = [];
+        this.validationRulesasync = [];
+        this.markAllAsTouched = false;
+        this.showMarkdown = false;
+        this.btnsText = {
+            Buttons: {
+                Bold: { title: this.utilityService.getResourceValue('Bold') },
+                Italic: { title: this.utilityService.getResourceValue('Italic') },
+                Heading: { title: this.utilityService.getResourceValue('Heading') },
+                Reference: { title: this.utilityService.getResourceValue('Reference') },
+                Link: { title: this.utilityService.getResourceValue('Link') },
+                Image: { title: this.utilityService.getResourceValue('Image') },
+                UnorderedList: { title: this.utilityService.getResourceValue('UnorderedList') },
+                OrderedList: { title: this.utilityService.getResourceValue('OrderedList') },
+                CodeBlock: { title: this.utilityService.getResourceValue('CodeBlock') },
+                ShowPreview: { title: this.utilityService.getResourceValue('ShowPreview') },
+                HidePreview: { title: this.utilityService.getResourceValue('HidePreview') },
+                Fullscreen: { title: this.utilityService.getResourceValue('Fullscreen') }
+            },
+            Upload: {
+                Drag: this.utilityService.getResourceValue('DragHere'),
+                Uploading: this.utilityService.getResourceValue('Uploading')
+            }
+        };
+        this.locales = {
+            en: this.btnsText,
+            ar: this.btnsText
+        };
+        this.resetError = () => {
+            this.controlValidationService.removeGlobalError();
+        };
+        //External Method
+        this.removeRequiredValidation = () => {
+            this.controlUtility.removeRequiredValidation(this.markdownEditorFormControl, this.validationRules, this.options);
+        };
+        //External Method
+        this.addRequiredValidation = () => {
+            this.controlUtility.addRequiredValidation(this.markdownEditorFormControl, this.validationRules, this.options);
+        };
+        //External Method
+        this.removeCustomValidation = (customValidation) => {
+            this.controlUtility.removeCustomValidation(this.markdownEditorFormControl, this.validationRules, customValidation);
+        };
+        //External Method
+        this.addCustomValidation = (customValidation) => {
+            this.controlUtility.addCustomValidation(this.markdownEditorFormControl, this.validationRules, customValidation);
+        };
+        //External Method
+        this.isValid = () => {
+            this.controlUtility.isValid(this.markdownEditorFormControl);
+        };
+        MarkdownEditorComponent.controlContainerstatic = this.controlContainer;
+        this.currentLocale = this.utilityService.getCurrentLanguage();
+    }
+    loadAllScripts() {
+        return this.scriptService.loadScript('assets/ace-builds/ace.js').pipe(switchMap(() => this.scriptService.loadScript('assets/ace-builds/mode-markdown.js')), switchMap(() => this.scriptService.loadScript('assets/ngx-markdown-editor/marked.min.js')), switchMap(() => this.scriptService.loadScript('assets/ngx-markdown-editor/highlight.js/highlight.min.js')));
+    }
+    ngOnInit() {
+        this.loadAllScripts()
+            .subscribe({
+            next: () => this.showMarkdown = true,
+            error: (err) => console.error('Error loading scripts', err)
+        });
+        this.mode = this.options.isReadonly ? MarkdownMode.preview : MarkdownMode.editor;
+        this.editorOptions = {
+            hideIcons: this.options.hideIcons,
+            showPreviewPanel: this.options.showPreviewPanelOnLoad,
+            resizable: false,
+            enablePreviewContentClick: this.options.isReadonly,
+            markedjsOpt: {
+                breaks: true,
+                sanitize: true,
+                smartypants: true,
+                xhtml: true,
+            },
+            customRender: this.options.customRender,
+            placeholder: this.options.placeholder,
+            locales: this.locales,
+            customIcons: {
+                CodeBlock: {
+                    fontClass: 'fa fa-file-code'
+                }
+            }
+        };
+        this.controlValidationService.isCreatedBefor = false;
+        this.group.addControl(this.options.name, new FormControl(''));
+        this.markdownEditorFormControl = this.group.controls[this.options.name]; //  new FormControl('',validationRules);
+        this.markdownEditorFormControl.setValue(this.options.value);
+        if (!this.options.viewType)
+            this.options.viewType = this.globalSettings.viewType;
+        if (this.options.customValidation.length > 0) {
+            let validations = this.options.customValidation;
+            for (let index = 0; index < validations.length; index++) {
+                const Validation = validations[index];
+                this.validationRules.push(Validation.functionBody);
+            }
+        }
+        if (this.options.labelKey != null && this.options.labelKey != "")
+            this.options.labelValue = this.utilityService.getResourceValue(this.options.labelKey);
+        if (this.options.minLength > 0) {
+            this.validationRules.push(Validators.minLength(this.options.minLength));
+        }
+        if (this.options.maxLength > 0) {
+            this.validationRules.push(Validators.maxLength(this.options.maxLength));
+        }
+        if (this.options.isRequired) {
+            this.validationRules.push(Validators.required);
+        }
+        this.markdownEditorFormControl.setValidators(this.validationRules);
+        this.markdownEditorFormControl.setAsyncValidators(this.validationRulesasync);
+        if (this.options.isDisabled) {
+            this.markdownEditorFormControl.disable();
+        }
+        this.markdownEditorControlHost.ngSubmit.subscribe((value) => {
+            this.group.markAllAsTouched();
+            this.markAllAsTouched = true;
+        });
+    }
+    uploadImg(evt) {
+        if (!evt)
+            return;
+        const file = evt.target.files[0];
+        const reader = new FileReader();
+        reader.addEventListener('load', () => {
+            this.options.value += `![](${reader.result})`;
+        }, false);
+        if (file)
+            reader.readAsDataURL(file);
+    }
+    onPreviewDomChanged(dom) {
+        this.OnChange.emit(dom);
+    }
+    showGlobalError() {
+        this.controlUtility.showGlobalError();
+    }
+    getErrorValidation(ErrorList) {
+        if (this.markAllAsTouched && this.group.invalid) {
+            this.showGlobalError();
+            this.markAllAsTouched = false;
+        }
+        return this.controlUtility.getErrorValidationMassage(ErrorList, this.group, this.options);
+    }
+    //Fires on markdown editor has been loaded
+    onEditorLoaded(editor) {
+        if (this.options.isDisabled) {
+            const textarea = editor.renderer.textarea;
+            if (textarea && this.options.isDisabled) {
+                textarea.setAttribute('disabled', 'true');
+            }
+            this.hideToolbar = true;
+        }
+    }
+    //The doUpload method handles file uploads when users add images or other files to the editor.
+    //This method should be implemented to manage file uploads to a server or cloud storage and return the result to the editor.
+    //fires on drag and drop or copy paste
+    //if not set will can't add files or images using this way
+    onDragFile(files) {
+        const results = [];
+        // Function to handle a single file
+        const processFile = (file) => {
+            return new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onload = () => {
+                    const fileUrl = reader.result;
+                    const result = {
+                        name: file.name,
+                        url: fileUrl,
+                        isImg: file.type.startsWith('image/')
+                    };
+                    resolve(result);
+                };
+                reader.onerror = (error) => {
+                    reject(error);
+                };
+                // Read the file as a data URL
+                reader.readAsDataURL(file);
+            });
+        };
+        //  // Iterate over files and process each one
+        const processAllFiles = async () => {
+            for (const file of files) {
+                try {
+                    const result = await processFile(file);
+                    results.push(result);
+                }
+                catch (error) {
+                    console.error('Error processing file:', error);
+                }
+            }
+            return results;
+        };
+        //Return the promise that resolves when all files are processed
+        return processAllFiles();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: MarkdownEditorComponent, deps: [{ token: i1.UtilityService }, { token: i2.GlobalSettings }, { token: i1.ControlValidationService }, { token: i3.ControlUtility }, { token: i4.FormGroupDirective }, { token: i5.ScriptService }, { token: i4.ControlContainer, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.6", type: MarkdownEditorComponent, selector: "BBSF-MarkdownEditor", inputs: { group: "group", options: "options" }, outputs: { OnChange: "OnChange" }, ngImport: i0, template: "<ng-container *ngIf=\"showMarkdown\">\r\n  <div class=\"form-group bbsf-control bbsf-htmleditor\" [formGroup]=\"group\">\r\n    <div [ngClass]=\"(options.viewType==1)?'bbsf-vertical':'bbsf-horizontal'\">\r\n      <!--label-->\r\n      <label *ngIf=\"!options.hideLabel\" class=\"bbsf-label {{options.labelExtraClasses}}\">\r\n        {{options.labelValue}}\r\n        <!--Asterisk-->\r\n        <span *ngIf=\"((options.showAsterisk&&options.isRequired)||(options.isRequired))&&!options.isReadonly\"\r\n          class=\"text-danger\">*</span>\r\n      </label>\r\n      <div  class=\"bbsf-input-container {{options.extraClasses}}\">\r\n          <md-editor   id=\"{{options.name}}\" formControlName=\"{{options.name}}\"\r\n         (onPreviewDomChanged)=\"onPreviewDomChanged($event)\"\r\n         [(ngModel)]=\"options.value\" [mode]=\"mode\" [options]=\"editorOptions\"  [attr.required]=\"options.isRequired ? true : null\" [upload]=\"onDragFile\" \r\n          [maxlength]=\"options.maxLength\" [height]=\"options.height\"  [locale]=\"currentLocale\"  (onEditorLoaded)=\"onEditorLoaded($event)\" [hideToolbar]=\"hideToolbar\">\r\n           <!-- [ngStyle]=\"{ 'direction': textDirection, 'text-align': textDirection === 'rtl' ? 'right' : 'left' }\" -->\r\n           <div custom-btns>\r\n            <input #imgInput type=\"file\" style=\"display: none\" (change)=\"uploadImg($event)\" />\r\n            <button type=\"button\" class=\"btn btn-sm btn-default\" (click)=\"imgInput.click()\">\r\n              {{utilityService.getResourceValue(\"UploadImg\")}}\r\n            </button>\r\n          </div>\r\n        </md-editor>\r\n      </div>\r\n\r\n      <div class=\"subtext-container\">\r\n        <div class=\"bbsf-control-desc\" *ngIf=\"options.labelDescription!=null\">{{options.labelDescription}}</div>\r\n        <div class=\"bbsf-validation\" *ngIf=\"(markdownEditorFormControl.invalid && markdownEditorFormControl.touched)\">\r\n          {{getErrorValidation(markdownEditorFormControl.errors|keyvalue)}}\r\n        </div>\r\n      </div>\r\n      <div *ngIf=\"(group.valid&&group.dirty&&group.touched )||(group.untouched&&group.invalid&&group.dirty) \">\r\n        {{resetError()}}</div>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n", dependencies: [{ kind: "directive", type: i6.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i7.NativeElementInjectorDirective, selector: "[ngModel], [formControl], [formControlName]" }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i4.MaxLengthValidator, selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", inputs: ["maxlength"] }, { kind: "directive", type: i4.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i4.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i8.MarkdownEditorComponent, selector: "md-editor", inputs: ["hideToolbar", "height", "preRender", "postRender", "upload", "locale", "maxlength", "mode", "options"], outputs: ["onEditorLoaded", "onPreviewDomChanged"] }, { kind: "pipe", type: i6.KeyValuePipe, name: "keyvalue" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: MarkdownEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'BBSF-MarkdownEditor', template: "<ng-container *ngIf=\"showMarkdown\">\r\n  <div class=\"form-group bbsf-control bbsf-htmleditor\" [formGroup]=\"group\">\r\n    <div [ngClass]=\"(options.viewType==1)?'bbsf-vertical':'bbsf-horizontal'\">\r\n      <!--label-->\r\n      <label *ngIf=\"!options.hideLabel\" class=\"bbsf-label {{options.labelExtraClasses}}\">\r\n        {{options.labelValue}}\r\n        <!--Asterisk-->\r\n        <span *ngIf=\"((options.showAsterisk&&options.isRequired)||(options.isRequired))&&!options.isReadonly\"\r\n          class=\"text-danger\">*</span>\r\n      </label>\r\n      <div  class=\"bbsf-input-container {{options.extraClasses}}\">\r\n          <md-editor   id=\"{{options.name}}\" formControlName=\"{{options.name}}\"\r\n         (onPreviewDomChanged)=\"onPreviewDomChanged($event)\"\r\n         [(ngModel)]=\"options.value\" [mode]=\"mode\" [options]=\"editorOptions\"  [attr.required]=\"options.isRequired ? true : null\" [upload]=\"onDragFile\" \r\n          [maxlength]=\"options.maxLength\" [height]=\"options.height\"  [locale]=\"currentLocale\"  (onEditorLoaded)=\"onEditorLoaded($event)\" [hideToolbar]=\"hideToolbar\">\r\n           <!-- [ngStyle]=\"{ 'direction': textDirection, 'text-align': textDirection === 'rtl' ? 'right' : 'left' }\" -->\r\n           <div custom-btns>\r\n            <input #imgInput type=\"file\" style=\"display: none\" (change)=\"uploadImg($event)\" />\r\n            <button type=\"button\" class=\"btn btn-sm btn-default\" (click)=\"imgInput.click()\">\r\n              {{utilityService.getResourceValue(\"UploadImg\")}}\r\n            </button>\r\n          </div>\r\n        </md-editor>\r\n      </div>\r\n\r\n      <div class=\"subtext-container\">\r\n        <div class=\"bbsf-control-desc\" *ngIf=\"options.labelDescription!=null\">{{options.labelDescription}}</div>\r\n        <div class=\"bbsf-validation\" *ngIf=\"(markdownEditorFormControl.invalid && markdownEditorFormControl.touched)\">\r\n          {{getErrorValidation(markdownEditorFormControl.errors|keyvalue)}}\r\n        </div>\r\n      </div>\r\n      <div *ngIf=\"(group.valid&&group.dirty&&group.touched )||(group.untouched&&group.invalid&&group.dirty) \">\r\n        {{resetError()}}</div>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n" }]
+        }], ctorParameters: () => [{ type: i1.UtilityService }, { type: i2.GlobalSettings }, { type: i1.ControlValidationService }, { type: i3.ControlUtility }, { type: i4.FormGroupDirective }, { type: i5.ScriptService }, { type: i4.ControlContainer, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { group: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], OnChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"markdown-editor.component.js","sourceRoot":"","sources":["../../../../../../projects/bbsf-controls/src/lib/controls/MarkdownEditor/markdown-editor.component.ts","../../../../../../projects/bbsf-controls/src/lib/controls/MarkdownEditor/markdown-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, EventEmitter, Input, OnInit, Optional, Output, ViewChild } from '@angular/core';\r\nimport { AbstractControl, ControlContainer, FormControl, FormGroup, FormGroupDirective, Validators } from '@angular/forms';\r\nimport { MdEditorOption } from \"ngx-markdown-editor\";\r\nimport { MarkdownEditorOptions } from '../../Shared/Models/MarkdownEditorOptions';\r\nimport { ControlValidationService, UtilityService } from '@bnsights/bbsf-utilities';\r\nimport { MdEditorLocaleOptions } from 'ngx-markdown-editor/lib/md-editor.types';\r\nimport { MarkdownMode } from '../../Shared/Enums/Markdown';\r\nimport { GlobalSettings } from '../../Shared/services/GlobalSettings.service';\r\nimport { ControlUtility } from '../../Shared/services/ControlUtility';\r\nimport { ScriptService } from 'ngx-script-loader';\r\nimport { switchMap } from 'rxjs';\r\n\r\n@Component({\r\n  selector: 'BBSF-MarkdownEditor',\r\n  templateUrl: './markdown-editor.component.html'\r\n})\r\nexport class MarkdownEditorComponent implements OnInit {\r\n  @Input() group: FormGroup;\r\n  @Input() options: MarkdownEditorOptions;\r\n  @Output() OnChange = new EventEmitter();\r\n  static controlContainerstatic = null;\r\n  markdownEditorFormControl: AbstractControl;\r\n  editorOptions: MdEditorOption;\r\n  mode: string;\r\n  hideToolbar: boolean = false;\r\n  currentLocale: string;\r\n  validationRules = [];\r\n  validationRulesasync = [];\r\n  markAllAsTouched: boolean = false;\r\n  showMarkdown:boolean=false;\r\n  btnsText = {\r\n    Buttons: {\r\n      Bold: { title: this.utilityService.getResourceValue('Bold') },\r\n      Italic: { title: this.utilityService.getResourceValue('Italic') },\r\n      Heading: { title: this.utilityService.getResourceValue('Heading') },\r\n      Reference: { title: this.utilityService.getResourceValue('Reference') },\r\n      Link: { title: this.utilityService.getResourceValue('Link') },\r\n      Image: { title: this.utilityService.getResourceValue('Image') },\r\n      UnorderedList: { title: this.utilityService.getResourceValue('UnorderedList') },\r\n      OrderedList: { title: this.utilityService.getResourceValue('OrderedList') },\r\n      CodeBlock: { title: this.utilityService.getResourceValue('CodeBlock') },\r\n      ShowPreview: { title: this.utilityService.getResourceValue('ShowPreview') },\r\n      HidePreview: { title: this.utilityService.getResourceValue('HidePreview') },\r\n      Fullscreen: { title: this.utilityService.getResourceValue('Fullscreen') }\r\n    },\r\n    Upload: {\r\n      Drag: this.utilityService.getResourceValue('DragHere'),\r\n      Uploading: this.utilityService.getResourceValue('Uploading')\r\n    }\r\n  }\r\n  locales: MdEditorLocaleOptions = {\r\n    en: this.btnsText,\r\n    ar: this.btnsText\r\n  }\r\n  constructor(public utilityService:UtilityService,private globalSettings: GlobalSettings,\r\n    private controlValidationService: ControlValidationService,private controlUtility: ControlUtility,\r\n    public markdownEditorControlHost: FormGroupDirective,private scriptService: ScriptService,\r\n    @Optional() private controlContainer: ControlContainer){\r\n    MarkdownEditorComponent.controlContainerstatic = this.controlContainer;\r\n    this.currentLocale = this.utilityService.getCurrentLanguage();\r\n    }\r\n   \r\n    private loadAllScripts() {\r\n      return this.scriptService.loadScript('assets/ace-builds/ace.js').pipe(\r\n        switchMap(() => this.scriptService.loadScript('assets/ace-builds/mode-markdown.js')),\r\n        switchMap(() => this.scriptService.loadScript('assets/ngx-markdown-editor/marked.min.js')),\r\n        switchMap(() => this.scriptService.loadScript('assets/ngx-markdown-editor/highlight.js/highlight.min.js'))\r\n      );\r\n    }\r\n  ngOnInit(): void {\r\n    this.loadAllScripts()\r\n      .subscribe({\r\n      next: () => this.showMarkdown = true,\r\n      error: (err) => console.error('Error loading scripts', err)\r\n    });\r\n\r\n    this.mode=this.options.isReadonly?MarkdownMode.preview: MarkdownMode.editor;\r\n    this.editorOptions = {\r\n      hideIcons: this.options.hideIcons,\r\n      showPreviewPanel: this.options.showPreviewPanelOnLoad,\r\n      resizable: false,\r\n      enablePreviewContentClick: this.options.isReadonly,// Allow user fire the click event on the preview panel, like href etc.\r\n      markedjsOpt: {\r\n        breaks: true,\r\n        sanitize: true,\r\n        smartypants: true,\r\n        xhtml: true,\r\n      },\r\n      customRender: this.options.customRender,\r\n      placeholder: this.options.placeholder,\r\n      locales: this.locales,\r\n      customIcons: {\r\n        CodeBlock: {\r\n          fontClass: 'fa fa-file-code'\r\n        }\r\n      }\r\n    }\r\n    this.controlValidationService.isCreatedBefor = false\r\n\r\n    this.group.addControl(this.options.name, new FormControl(''));\r\n    this.markdownEditorFormControl = this.group.controls[this.options.name]; //  new FormControl('',validationRules);\r\n    this.markdownEditorFormControl.setValue(this.options.value);\r\n\r\n    if (!this.options.viewType)\r\n      this.options.viewType = this.globalSettings.viewType;\r\n\r\n    if (this.options.customValidation.length > 0) {\r\n      let validations = this.options.customValidation\r\n      for (let index = 0; index < validations.length; index++) {\r\n        const Validation = validations[index];\r\n        this.validationRules.push(Validation.functionBody);\r\n      }\r\n\r\n    }\r\n\r\n    if (this.options.labelKey != null && this.options.labelKey != \"\")\r\n      this.options.labelValue = this.utilityService.getResourceValue(this.options.labelKey);\r\n\r\n    if (this.options.minLength > 0) {\r\n      this.validationRules.push(Validators.minLength(this.options.minLength));\r\n    }\r\n    if (this.options.maxLength > 0) {\r\n      this.validationRules.push(Validators.maxLength(this.options.maxLength));\r\n    }\r\n    if (this.options.isRequired) {\r\n      this.validationRules.push(Validators.required);\r\n    }\r\n    this.markdownEditorFormControl.setValidators(this.validationRules);\r\n    this.markdownEditorFormControl.setAsyncValidators(this.validationRulesasync);\r\n    if (this.options.isDisabled) {\r\n      this.markdownEditorFormControl.disable();\r\n    }\r\n\r\n    this.markdownEditorControlHost.ngSubmit.subscribe((value) => {\r\n      this.group.markAllAsTouched()\r\n      this.markAllAsTouched = true\r\n    })\r\n  }\r\n\r\n  uploadImg(evt: any) {\r\n    if (!evt) return;\r\n    const file = evt.target.files[0];\r\n    const reader = new FileReader();\r\n    reader.addEventListener(\r\n      'load',\r\n      () => {\r\n        this.options.value += `![](${reader.result})`;\r\n      },\r\n      false\r\n    );\r\n    if (file) reader.readAsDataURL(file);\r\n  }\r\n  onPreviewDomChanged(dom: any) {\r\n    this.OnChange.emit(dom)\r\n  }\r\n  resetError = () => {\r\n    this.controlValidationService.removeGlobalError();\r\n  }\r\n  showGlobalError() {\r\n    this.controlUtility.showGlobalError()\r\n  }\r\n  getErrorValidation(ErrorList) {\r\n    if (this.markAllAsTouched && this.group.invalid) {\r\n      this.showGlobalError()\r\n      this.markAllAsTouched = false\r\n    }\r\n\r\n    return this.controlUtility.getErrorValidationMassage(ErrorList, this.group, this.options);\r\n  }\r\n\r\n  //External Method\r\n\r\n  removeRequiredValidation = () => {\r\n    this.controlUtility.removeRequiredValidation(this.markdownEditorFormControl, this.validationRules, this.options)\r\n  }\r\n  //External Method\r\n\r\n  addRequiredValidation = () => {\r\n    this.controlUtility.addRequiredValidation(this.markdownEditorFormControl, this.validationRules, this.options)\r\n  }\r\n\r\n\r\n  //External Method\r\n  removeCustomValidation = (customValidation) => {\r\n    this.controlUtility.removeCustomValidation(this.markdownEditorFormControl, this.validationRules, customValidation)\r\n  }\r\n  //External Method\r\n  addCustomValidation = (customValidation) => {\r\n    this.controlUtility.addCustomValidation(this.markdownEditorFormControl, this.validationRules, customValidation)\r\n  }\r\n\r\n  //External Method\r\n  isValid = () => {\r\n    this.controlUtility.isValid(this.markdownEditorFormControl)\r\n  }\r\n  //Fires on markdown editor has been loaded\r\n  onEditorLoaded(editor: any) {\r\n    if (this.options.isDisabled) {\r\n      const textarea = editor.renderer.textarea;\r\n      if (textarea && this.options.isDisabled) {\r\n        textarea.setAttribute('disabled', 'true');\r\n      }\r\n      this.hideToolbar = true;\r\n    }\r\n  }\r\n\r\n  //The doUpload method handles file uploads when users add images or other files to the editor.\r\n  //This method should be implemented to manage file uploads to a server or cloud storage and return the result to the editor.\r\n  //fires on drag and drop or copy paste\r\n  //if not set will can't add files or images using this way\r\n  onDragFile(files: Array<File>): Promise<Array<any>> {\r\n    const results: Array<any> = [];\r\n\r\n    // Function to handle a single file\r\n    const processFile = (file: File) => {\r\n      return new Promise<any>((resolve, reject) => {\r\n        const reader = new FileReader();\r\n\r\n        reader.onload = () => {\r\n          const fileUrl = reader.result as string;\r\n          const result = {\r\n            name: file.name,\r\n            url: fileUrl,\r\n            isImg: file.type.startsWith('image/')\r\n          };\r\n          resolve(result);\r\n        };\r\n\r\n        reader.onerror = (error) => {\r\n          reject(error);\r\n        };\r\n\r\n        // Read the file as a data URL\r\n        reader.readAsDataURL(file);\r\n      });\r\n    };\r\n\r\n    //  // Iterate over files and process each one\r\n    const processAllFiles = async () => {\r\n      for (const file of files) {\r\n        try {\r\n          const result = await processFile(file);\r\n          results.push(result);\r\n        } catch (error) {\r\n          console.error('Error processing file:', error);\r\n        }\r\n      }\r\n      return results;\r\n    };\r\n\r\n    //Return the promise that resolves when all files are processed\r\n    return processAllFiles();\r\n  }\r\n\r\n\r\n}\r\n","<ng-container *ngIf=\"showMarkdown\">\r\n  <div class=\"form-group bbsf-control bbsf-htmleditor\" [formGroup]=\"group\">\r\n    <div [ngClass]=\"(options.viewType==1)?'bbsf-vertical':'bbsf-horizontal'\">\r\n      <!--label-->\r\n      <label *ngIf=\"!options.hideLabel\" class=\"bbsf-label {{options.labelExtraClasses}}\">\r\n        {{options.labelValue}}\r\n        <!--Asterisk-->\r\n        <span *ngIf=\"((options.showAsterisk&&options.isRequired)||(options.isRequired))&&!options.isReadonly\"\r\n          class=\"text-danger\">*</span>\r\n      </label>\r\n      <div  class=\"bbsf-input-container {{options.extraClasses}}\">\r\n          <md-editor   id=\"{{options.name}}\" formControlName=\"{{options.name}}\"\r\n         (onPreviewDomChanged)=\"onPreviewDomChanged($event)\"\r\n         [(ngModel)]=\"options.value\" [mode]=\"mode\" [options]=\"editorOptions\"  [attr.required]=\"options.isRequired ? true : null\" [upload]=\"onDragFile\" \r\n          [maxlength]=\"options.maxLength\" [height]=\"options.height\"  [locale]=\"currentLocale\"  (onEditorLoaded)=\"onEditorLoaded($event)\" [hideToolbar]=\"hideToolbar\">\r\n           <!-- [ngStyle]=\"{ 'direction': textDirection, 'text-align': textDirection === 'rtl' ? 'right' : 'left' }\" -->\r\n           <div custom-btns>\r\n            <input #imgInput type=\"file\" style=\"display: none\" (change)=\"uploadImg($event)\" />\r\n            <button type=\"button\" class=\"btn btn-sm btn-default\" (click)=\"imgInput.click()\">\r\n              {{utilityService.getResourceValue(\"UploadImg\")}}\r\n            </button>\r\n          </div>\r\n        </md-editor>\r\n      </div>\r\n\r\n      <div class=\"subtext-container\">\r\n        <div class=\"bbsf-control-desc\" *ngIf=\"options.labelDescription!=null\">{{options.labelDescription}}</div>\r\n        <div class=\"bbsf-validation\" *ngIf=\"(markdownEditorFormControl.invalid && markdownEditorFormControl.touched)\">\r\n          {{getErrorValidation(markdownEditorFormControl.errors|keyvalue)}}\r\n        </div>\r\n      </div>\r\n      <div *ngIf=\"(group.valid&&group.dirty&&group.touched )||(group.untouched&&group.invalid&&group.dirty) \">\r\n        {{resetError()}}</div>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n"]}