@ajf/material 13.0.0-next.0

package/esm2015/report-builder/public-api.js

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright (C) Gnucoop soc. coop.
+ *
+ * This file is part of the Advanced JSON forms (ajf).
+ *
+ * Advanced JSON forms (ajf) is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * Advanced JSON forms (ajf) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Advanced JSON forms (ajf).
+ * If not, see http://www.gnu.org/licenses/.
+ *
+ */
+export * from './report-builder-module';
+export * from './report-builder-service';
+export * from './report-builder';
+export * from './tokens';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9tYXRlcmlhbC9yZXBvcnQtYnVpbGRlci9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQW9CRztBQUdILGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IChDKSBHbnVjb29wIHNvYy4gY29vcC5cbiAqXG4gKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgQWR2YW5jZWQgSlNPTiBmb3JtcyAoYWpmKS5cbiAqXG4gKiBBZHZhbmNlZCBKU09OIGZvcm1zIChhamYpIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vclxuICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEFmZmVybyBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzXG4gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSxcbiAqIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uXG4gKlxuICogQWR2YW5jZWQgSlNPTiBmb3JtcyAoYWpmKSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLFxuICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2ZcbiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZSBHTlUgQWZmZXJvXG4gKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuXG4gKlxuICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEFmZmVybyBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlXG4gKiBhbG9uZyB3aXRoIEFkdmFuY2VkIEpTT04gZm9ybXMgKGFqZikuXG4gKiBJZiBub3QsIHNlZSBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvLlxuICpcbiAqL1xuXG5leHBvcnQge0FqZlJlcG9ydHNDb25maWd9IGZyb20gJy4vbW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vcmVwb3J0LWJ1aWxkZXItbW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vcmVwb3J0LWJ1aWxkZXItc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3JlcG9ydC1idWlsZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vdG9rZW5zJztcbiJdfQ==

package/esm2015/report-builder/quill-editor.js

@@ -0,0 +1,299 @@
+/**
+ * @license
+ * Copyright (C) Gnucoop soc. coop.
+ *
+ * This file is part of the Advanced JSON forms (ajf).
+ *
+ * Advanced JSON forms (ajf) is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * Advanced JSON forms (ajf) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Advanced JSON forms (ajf).
+ * If not, see http://www.gnu.org/licenses/.
+ *
+ */
+import { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, forwardRef, Input, Output, Renderer2, ViewEncapsulation } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { default as Quill } from 'quill';
+import { Subscription } from 'rxjs';
+import { AjfReportBuilderService } from './report-builder-service';
+export class AjfQuillEditor {
+    constructor(_elementRef, _renderer, _service) {
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+        this._service = _service;
+        this.emptyArray = [];
+        this._init = false;
+        this.dateFormats = [
+            {
+                'label': 'June 23rd 2017, 12:39:12 pm',
+                'value': 'MMMM Do YYYY, h:mm:ss a',
+                'validator': 'MMMMDoYYYYhmmssa'
+            },
+            { 'label': 'Friday', 'value': 'dddd', 'validator': 'dddd' },
+            { 'label': 'Jun 23rd 17', 'value': 'MMM Do YY', 'validator': 'MMMDoYY' }
+        ];
+        this.fonts = [
+            false, 'blackr', 'black-italic', 'bold', 'bold-condensed', 'bold-condensed-italic',
+            'bold-italic', 'condensed', 'condensed-italic', 'italic', 'light', 'light-italic', 'medium',
+            'medium-italic', 'thinr', 'thin-italic'
+        ];
+        this.defaultModules = {
+            formula: true,
+            toolbar: [
+                ['formula'], ['bold', 'italic', 'underline', 'strike'],
+                // ['blockquote', 'code-block'],
+                [{ 'header': 1 }, { 'header': 2 }],
+                [{ 'list': 'ordered' }, { 'list': 'bullet' }],
+                [{ 'script': 'sub' }, { 'script': 'super' }],
+                // [{ 'indent': '-1'}, { 'indent': '+1' }],          // outdent/indent
+                // [{ 'direction': 'rtl' }],                         // text direction
+                [{ 'size': ['small', false, 'large', 'huge'] }],
+                [{ 'header': [1, 2, 3, 4, 5, 6, false] }],
+                [
+                    { 'color': this.emptyArray.slice() }, { 'background': this.emptyArray.slice() }
+                ],
+                [{ 'font': this.fonts }], [{ 'align': this.emptyArray.slice() }],
+                ['clean'], // remove formatting button
+                // ['link', 'image', 'video']                         // link and image, video
+            ]
+        };
+        this.font = Quill.import('formats/font');
+        this.editorCreated = new EventEmitter();
+        this.contentChanged = new EventEmitter();
+        this.selectionChanged = new EventEmitter();
+        /**
+         * this event is fired when the user click on formula button on quill editor rool barƒ
+         *
+         * @memberof QuillEditorComponent
+         */
+        this.formulaClick = new EventEmitter();
+        this.onModelChange = () => { };
+        this.onModelTouched = () => { };
+        this._formulas = [];
+        this._formulaTextSub = Subscription.EMPTY;
+        this.font.whitelist = this.fonts;
+        this.font.whitelist.push('regular');
+        this._formulaTextSub = this._service.getFormulaToHtmlEvent().subscribe((event) => {
+            // reference is defined only when the user want to edit the formula
+            if (event.reference !== undefined) {
+                event.reference.innerHTML = event.formula;
+                this._renderer.setAttribute(event.reference, 'formula', event.formula);
+                const efs = this._formulas.filter(f => f.formula === event.reference);
+                let formulaEntry;
+                let unlisten;
+                if (efs.length > 0) {
+                    formulaEntry = efs[0];
+                    unlisten = formulaEntry.unlisten;
+                    if (unlisten != null) {
+                        unlisten();
+                    }
+                }
+                else {
+                    formulaEntry = { formula: event.reference, unlisten: null };
+                    this._formulas.push(formulaEntry);
+                }
+                formulaEntry.unlisten = this._renderer.listen(event.reference, 'click', () => {
+                    let obj = { 'formula': event.formula, 'reference': event.reference };
+                    this.formulaClick.emit(obj);
+                });
+            }
+            else {
+                const quillEditor = this._elementRef.nativeElement.querySelector('.ajf-ql-editor');
+                const link = this._renderer.createElement('a');
+                this._renderer.setAttribute(link, 'href', 'javascript:void(0)');
+                this._renderer.setStyle(link, 'cursor', 'pointer');
+                this._renderer.setAttribute(link, 'formula', this.check(event.formula));
+                const linkLabel = this._renderer.createText(event.formula);
+                this._renderer.appendChild(link, linkLabel);
+                // add listener related on the click event of the new formula
+                const unlisten = this._renderer.listen(link, 'click', (_) => {
+                    let obj = { 'formula': this.check(event.formula), 'reference': link };
+                    this.formulaClick.emit(obj);
+                });
+                this._renderer.appendChild(quillEditor, link);
+                this._formulas.push({ unlisten, formula: link });
+            }
+        });
+    }
+    check(value) {
+        for (let i = 0; i < this.dateFormats.length; i++) {
+            if (this.dateFormats[i].value == value) {
+                return this.dateFormats[i].validator;
+            }
+        }
+        return value;
+    }
+    /**
+     * this function search fomulas inside the init text
+     * and allocate the related listener on click event
+     *
+     * @memberof QuillEditorComponent
+     */
+    setHTML() {
+        this.writeValue(this.initHTML);
+    }
+    ngAfterViewInit() {
+        const toolbarElem = this._elementRef.nativeElement.querySelector('[ajf-quill-editor-toolbar]');
+        let modules = this.modules || this.defaultModules;
+        Quill.register(this.font, true);
+        if (toolbarElem) {
+            modules['toolbar'] = toolbarElem;
+            modules['formula'] = true;
+        }
+        this._elementRef.nativeElement.insertAdjacentHTML('beforeend', '<div quill-editor-element></div>');
+        this.editorElem = this._elementRef.nativeElement.querySelector('[quill-editor-element]');
+        this.quillEditor = new Quill(this.editorElem, {
+            modules: modules,
+            placeholder: this.placeholder || 'Insert text here ...',
+            readOnly: this.readOnly || false,
+            theme: this.theme || 'snow',
+            formats: this.formats
+        });
+        this.editorCreated.emit(this.quillEditor);
+        this.setHTML();
+        // mark model as touched if editor lost focus
+        this.quillEditor.on('selection-change', (range, oldRange, source) => {
+            this.selectionChanged.emit({ editor: this.quillEditor, range: range, oldRange: oldRange, source: source });
+            if (!range) {
+                this.onModelTouched();
+            }
+        });
+        // update model if text changes
+        this.quillEditor.on('text-change', (delta, oldDelta, source) => {
+            let html = this.editorElem.children[0].innerHTML;
+            const text = this.quillEditor.getText();
+            if (html === '<p><br></p>') {
+                html = null;
+            }
+            this.onModelChange(html);
+            this.contentChanged.emit({
+                editor: this.quillEditor,
+                html: html,
+                text: text,
+                delta: delta,
+                oldDelta: oldDelta,
+                source: source
+            });
+        });
+        let elem = this._elementRef.nativeElement.querySelector('.ajf-ql-formula');
+        this.listenFunc = this._renderer.listen(elem, 'click', (_) => {
+            this.formulaClick.emit();
+        });
+    }
+    writeValue(currentValue) {
+        this.content = currentValue;
+        if (this.quillEditor) {
+            if (currentValue) {
+                if (currentValue == this.initHTML && !this._init) {
+                    let editor = this._elementRef.nativeElement.querySelector('.ajf-ql-editor');
+                    editor.innerHTML = this.initHTML;
+                    let allFormulas = this._elementRef.nativeElement.querySelectorAll('[formula]');
+                    allFormulas.forEach((elem) => {
+                        const unlisten = this._renderer.listen(elem, 'click', (_) => {
+                            let obj = { 'formula': this.check(elem.innerText), 'reference': elem };
+                            this.formulaClick.emit(obj);
+                        });
+                        this._renderer.setStyle(elem, 'cursor', 'pointer');
+                        this._formulas.push({ unlisten, formula: elem });
+                        this._init = true;
+                    });
+                }
+                else if (currentValue != this.initHTML) {
+                    this.quillEditor.pasteHTML(currentValue);
+                }
+                return;
+            }
+            this.quillEditor.setText('');
+        }
+    }
+    registerOnChange(fn) {
+        this.onModelChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onModelTouched = fn;
+    }
+    validate(_c) {
+        if (!this.quillEditor) {
+            return null;
+        }
+        let err = {}, valid = true;
+        const textLength = this.quillEditor.getText().trim().length;
+        if (this.minLength) {
+            err.minLengthError = { given: textLength, minLength: this.minLength };
+            valid = textLength >= this.minLength || !textLength;
+        }
+        if (this.maxLength) {
+            err.maxLengthError = { given: textLength, maxLength: this.maxLength };
+            valid = textLength <= this.maxLength && valid;
+        }
+        return valid ? null : err;
+    }
+    ngOnChanges(changes) {
+        if (changes['readOnly'] && this.quillEditor) {
+            this.quillEditor.enable(!changes['readOnly'].currentValue);
+        }
+        if (changes['modules'] && this.quillEditor) {
+            Quill.register(this.font, true);
+            this.quillEditor = new Quill(this.editorElem, {
+                modules: changes['modules']['currentValue'],
+                placeholder: this.placeholder || 'Insert text here ...',
+                readOnly: this.readOnly || false,
+                theme: this.theme || 'snow',
+                formats: this.formats
+            });
+            this._elementRef.nativeElement.children[0].remove();
+        }
+    }
+    ngOnDestroy() {
+        for (let i = 0; i < this._formulas.length; i++) {
+            let unlisten = this._formulas[i].unlisten;
+            if (unlisten != null) {
+                unlisten();
+            }
+        }
+        this._formulaTextSub.unsubscribe();
+    }
+}
+AjfQuillEditor.decorators = [
+    { type: Component, args: [{
+                selector: 'ajf-quill-editor',
+                template: `
+    <ng-content select="[ajf-quill-editor-toolbar]"></ng-content>
+  `,
+                providers: [
+                    { provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => AjfQuillEditor), multi: true },
+                    { provide: NG_VALIDATORS, useExisting: forwardRef(() => AjfQuillEditor), multi: true }
+                ],
+                encapsulation: ViewEncapsulation.None,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: ["ajf-quill-editor .ajf-ql-container .ajf-ql-editor{min-height:200px;width:500px !important;padding-bottom:50px}\n"]
+            },] }
+];
+AjfQuillEditor.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Renderer2 },
+    { type: AjfReportBuilderService }
+];
+AjfQuillEditor.propDecorators = {
+    theme: [{ type: Input }],
+    modules: [{ type: Input }],
+    readOnly: [{ type: Input }],
+    placeholder: [{ type: Input }],
+    maxLength: [{ type: Input }],
+    minLength: [{ type: Input }],
+    formats: [{ type: Input }],
+    initHTML: [{ type: Input }],
+    editorCreated: [{ type: Output }],
+    contentChanged: [{ type: Output }],
+    selectionChanged: [{ type: Output }],
+    formulaClick: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quill-editor.js","sourceRoot":"","sources":["../../../../../../src/material/report-builder/quill-editor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright (C) Gnucoop soc. coop.\n *\n * This file is part of the Advanced JSON forms (ajf).\n *\n * Advanced JSON forms (ajf) is free software: you can redistribute it and/or\n * modify it under the terms of the GNU Affero General Public License as\n * published by the Free Software Foundation, either version 3 of the License,\n * or (at your option) any later version.\n *\n * Advanced JSON forms (ajf) is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero\n * General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Advanced JSON forms (ajf).\n * If not, see http://www.gnu.org/licenses/.\n *\n */\n\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  Renderer2,\n  SimpleChanges,\n  ViewEncapsulation\n} from '@angular/core';\nimport {\n  ControlValueAccessor,\n  FormControl,\n  NG_VALIDATORS,\n  NG_VALUE_ACCESSOR,\n  Validator\n} from '@angular/forms';\nimport {default as Quill} from 'quill';\nimport {Subscription} from 'rxjs';\n\nimport {AjfReportBuilderService} from './report-builder-service';\n\n\n@Component({\n  selector: 'ajf-quill-editor',\n  template: `\n    <ng-content select=\"[ajf-quill-editor-toolbar]\"></ng-content>\n  `,\n  providers: [\n    {provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => AjfQuillEditor), multi: true},\n    {provide: NG_VALIDATORS, useExisting: forwardRef(() => AjfQuillEditor), multi: true}\n  ],\n  styleUrls: ['quill-editor.css'],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class AjfQuillEditor implements AfterViewInit, ControlValueAccessor, OnChanges, OnDestroy,\n                                       Validator {\n  quillEditor: any;\n  editorElem: HTMLElement;\n  emptyArray: any[] = [];\n  content: any;\n\n  listenFunc: Function;\n\n  previewElemFormula: any;\n  private _init: boolean = false;\n\n  dateFormats = [\n    {\n      'label': 'June 23rd 2017, 12:39:12 pm',\n      'value': 'MMMM Do YYYY, h:mm:ss a',\n      'validator': 'MMMMDoYYYYhmmssa'\n    },\n    {'label': 'Friday', 'value': 'dddd', 'validator': 'dddd'},\n    {'label': 'Jun 23rd 17', 'value': 'MMM Do YY', 'validator': 'MMMDoYY'}\n  ];\n\n\n  fonts = [\n    false, 'blackr', 'black-italic', 'bold', 'bold-condensed', 'bold-condensed-italic',\n    'bold-italic', 'condensed', 'condensed-italic', 'italic', 'light', 'light-italic', 'medium',\n    'medium-italic', 'thinr', 'thin-italic'\n  ];\n\n  defaultModules = {\n    formula: true,\n    toolbar:\n        [\n          ['formula'], ['bold', 'italic', 'underline', 'strike'],  // toggled buttons\n          // ['blockquote', 'code-block'],\n\n          [{'header': 1}, {'header': 2}],  // custom button values\n          [{'list': 'ordered'}, {'list': 'bullet'}],\n          [{'script': 'sub'}, {'script': 'super'}],  // superscript/subscript\n          // [{ 'indent': '-1'}, { 'indent': '+1' }],          // outdent/indent\n          // [{ 'direction': 'rtl' }],                         // text direction\n\n          [{'size': ['small', false, 'large', 'huge']}],  // custom dropdown\n          [{'header': [1, 2, 3, 4, 5, 6, false]}],\n\n          [\n            {'color': this.emptyArray.slice()}, {'background': this.emptyArray.slice()}\n          ],  // dropdown with defaults from theme\n          [{'font': this.fonts}], [{'align': this.emptyArray.slice()}],\n\n          ['clean'],  // remove formatting button\n\n          // ['link', 'image', 'video']                         // link and image, video\n        ]\n  };\n\n  font = Quill.import('formats/font');\n\n\n  @Input() theme: string;\n  @Input() modules: Object;\n  @Input() readOnly: boolean;\n  @Input() placeholder: string;\n  @Input() maxLength: number;\n  @Input() minLength: number;\n  @Input() formats: string[];\n  @Input() initHTML: string;\n\n  @Output() readonly editorCreated: EventEmitter<any> = new EventEmitter();\n  @Output() readonly contentChanged: EventEmitter<any> = new EventEmitter();\n  @Output() readonly selectionChanged: EventEmitter<any> = new EventEmitter();\n\n\n  /**\n   * this event is fired when the user click on formula button on quill editor rool barƒ\n   *\n   * @memberof QuillEditorComponent\n   */\n  @Output() readonly formulaClick: EventEmitter<any> = new EventEmitter<any>();\n\n\n  onModelChange: Function = () => {};\n  onModelTouched: Function = () => {};\n\n  private _formulas: {formula: any, unlisten: Function|null}[] = [];\n  private _formulaTextSub: Subscription = Subscription.EMPTY;\n\n  constructor(\n      private _elementRef: ElementRef, private _renderer: Renderer2,\n      private _service: AjfReportBuilderService) {\n    this.font.whitelist = this.fonts;\n    this.font.whitelist.push('regular');\n\n    this._formulaTextSub = this._service.getFormulaToHtmlEvent().subscribe((event: any) => {\n      // reference is defined only when the user want to edit the formula\n      if (event.reference !== undefined) {\n        event.reference.innerHTML = event.formula;\n        this._renderer.setAttribute(event.reference, 'formula', event.formula);\n        const efs = this._formulas.filter(f => f.formula === event.reference);\n        let formulaEntry;\n        let unlisten;\n        if (efs.length > 0) {\n          formulaEntry = efs[0];\n          unlisten = formulaEntry.unlisten;\n          if (unlisten != null) {\n            unlisten();\n          }\n        } else {\n          formulaEntry = {formula: event.reference, unlisten: null};\n          this._formulas.push(formulaEntry);\n        }\n        formulaEntry.unlisten = this._renderer.listen(event.reference, 'click', () => {\n          let obj = {'formula': event.formula, 'reference': event.reference};\n          this.formulaClick.emit(obj);\n        });\n      } else {\n        const quillEditor = this._elementRef.nativeElement.querySelector('.ajf-ql-editor');\n        const link = this._renderer.createElement('a');\n        this._renderer.setAttribute(link, 'href', 'javascript:void(0)');\n        this._renderer.setStyle(link, 'cursor', 'pointer');\n        this._renderer.setAttribute(link, 'formula', this.check(event.formula));\n        const linkLabel = this._renderer.createText(event.formula);\n        this._renderer.appendChild(link, linkLabel);\n        // add listener related on the click event of the new formula\n        const unlisten = this._renderer.listen(link, 'click', (_) => {\n          let obj = {'formula': this.check(event.formula), 'reference': link};\n          this.formulaClick.emit(obj);\n        });\n        this._renderer.appendChild(quillEditor, link);\n        this._formulas.push({unlisten, formula: link});\n      }\n    });\n  }\n\n  check(value: string): string {\n    for (let i = 0; i < this.dateFormats.length; i++) {\n      if (this.dateFormats[i].value == value) {\n        return this.dateFormats[i].validator;\n      }\n    }\n    return <string>value;\n  }\n  /**\n   * this function search fomulas inside the init text\n   * and allocate the related listener on click event\n   *\n   * @memberof QuillEditorComponent\n   */\n  setHTML() {\n    this.writeValue(this.initHTML);\n  }\n\n  ngAfterViewInit() {\n    const toolbarElem = this._elementRef.nativeElement.querySelector('[ajf-quill-editor-toolbar]');\n    let modules: any = this.modules || this.defaultModules;\n\n    Quill.register(this.font, true);\n\n    if (toolbarElem) {\n      modules['toolbar'] = toolbarElem;\n      modules['formula'] = true;\n    }\n    this._elementRef.nativeElement.insertAdjacentHTML(\n        'beforeend', '<div quill-editor-element></div>');\n\n    this.editorElem = this._elementRef.nativeElement.querySelector('[quill-editor-element]');\n\n    this.quillEditor = new Quill(this.editorElem, {\n      modules: modules,\n      placeholder: this.placeholder || 'Insert text here ...',\n      readOnly: this.readOnly || false,\n      theme: this.theme || 'snow',\n      formats: this.formats\n    });\n\n\n    this.editorCreated.emit(this.quillEditor);\n    this.setHTML();\n\n    // mark model as touched if editor lost focus\n    this.quillEditor.on('selection-change', (range: any, oldRange: any, source: string) => {\n      this.selectionChanged.emit(\n          {editor: this.quillEditor, range: range, oldRange: oldRange, source: source});\n\n      if (!range) {\n        this.onModelTouched();\n      }\n    });\n\n    // update model if text changes\n    this.quillEditor.on('text-change', (delta: any, oldDelta: any, source: string) => {\n      let html: any = this.editorElem.children[0].innerHTML;\n      const text = this.quillEditor.getText();\n\n      if (html === '<p><br></p>') {\n        html = null;\n      }\n\n      this.onModelChange(html);\n\n      this.contentChanged.emit({\n        editor: this.quillEditor,\n        html: html,\n        text: text,\n        delta: delta,\n        oldDelta: oldDelta,\n        source: source\n      });\n    });\n\n    let elem = this._elementRef.nativeElement.querySelector('.ajf-ql-formula');\n    this.listenFunc = this._renderer.listen(elem, 'click', (_) => {\n      this.formulaClick.emit();\n    });\n  }\n\n  writeValue(currentValue: any) {\n    this.content = currentValue;\n\n    if (this.quillEditor) {\n      if (currentValue) {\n        if (currentValue == this.initHTML && !this._init) {\n          let editor = this._elementRef.nativeElement.querySelector('.ajf-ql-editor');\n          editor.innerHTML = this.initHTML;\n          let allFormulas = this._elementRef.nativeElement.querySelectorAll('[formula]');\n          allFormulas.forEach((elem: any) => {\n            const unlisten = this._renderer.listen(elem, 'click', (_) => {\n              let obj = {'formula': this.check(elem.innerText), 'reference': elem};\n              this.formulaClick.emit(obj);\n            });\n            this._renderer.setStyle(elem, 'cursor', 'pointer');\n            this._formulas.push({unlisten, formula: elem});\n            this._init = true;\n          });\n        } else if (currentValue != this.initHTML) {\n          this.quillEditor.pasteHTML(currentValue);\n        }\n        return;\n      }\n      this.quillEditor.setText('');\n    }\n  }\n\n  registerOnChange(fn: Function): void {\n    this.onModelChange = fn;\n  }\n\n  registerOnTouched(fn: Function): void {\n    this.onModelTouched = fn;\n  }\n\n  validate(_c: FormControl) {\n    if (!this.quillEditor) {\n      return null;\n    }\n\n    let err: {\n      minLengthError?: {given: number, minLength: number};\n      maxLengthError?: {given: number, maxLength: number};\n    } = {},\n  valid = true;\n\n    const textLength = this.quillEditor.getText().trim().length;\n\n    if (this.minLength) {\n      err.minLengthError = {given: textLength, minLength: this.minLength};\n\n      valid = textLength >= this.minLength || !textLength;\n    }\n\n    if (this.maxLength) {\n      err.maxLengthError = {given: textLength, maxLength: this.maxLength};\n\n      valid = textLength <= this.maxLength && valid;\n    }\n\n    return valid ? null : err;\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['readOnly'] && this.quillEditor) {\n      this.quillEditor.enable(!changes['readOnly'].currentValue);\n    }\n    if (changes['modules'] && this.quillEditor) {\n      Quill.register(this.font, true);\n      this.quillEditor = new Quill(this.editorElem, {\n        modules: changes['modules']['currentValue'],\n        placeholder: this.placeholder || 'Insert text here ...',\n        readOnly: this.readOnly || false,\n        theme: this.theme || 'snow',\n        formats: this.formats\n      });\n      this._elementRef.nativeElement.children[0].remove();\n    }\n  }\n  ngOnDestroy() {\n    for (let i = 0; i < this._formulas.length; i++) {\n      let unlisten = this._formulas[i].unlisten;\n      if (unlisten != null) {\n        unlisten();\n      }\n    }\n    this._formulaTextSub.unsubscribe();\n  }\n}\n"]}