@firestitch/text-editor 12.3.1 → 12.4.1

package/esm2015/app/modules/ngx-monaco-editor/editor.component.js

@@ -0,0 +1,121 @@
+import { Component, forwardRef, Inject, Input, NgZone } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { fromEvent } from 'rxjs';
+import { BaseEditor } from './base-editor';
+import { NGX_MONACO_EDITOR_CONFIG } from './config';
+import * as i0 from "@angular/core";
+export class EditorComponent extends BaseEditor {
+    constructor(zone, editorConfig) {
+        super(editorConfig);
+        this.zone = zone;
+        this.editorConfig = editorConfig;
+        this._value = '';
+        this.propagateChange = (_) => { };
+        this.onTouched = () => { };
+    }
+    set options(options) {
+        this._options = Object.assign({}, this.config.defaultOptions, options);
+        if (this._editor) {
+            this._editor.dispose();
+            this.initMonaco(options);
+        }
+    }
+    get options() {
+        return this._options;
+    }
+    set model(model) {
+        this.options.model = model;
+        if (this._editor) {
+            this._editor.dispose();
+            this.initMonaco(this.options);
+        }
+    }
+    writeValue(value) {
+        this._value = value || '';
+        // Fix for value change while dispose in process.
+        setTimeout(() => {
+            if (this._editor && !this.options.model) {
+                this._editor.setValue(this._value);
+            }
+        });
+    }
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    initMonaco(options) {
+        const hasModel = !!options.model;
+        if (hasModel) {
+            const model = monaco.editor.getModel(options.model.uri || '');
+            if (model) {
+                options.model = model;
+                options.model.setValue(this._value);
+            }
+            else {
+                options.model = monaco.editor.createModel(options.model.value, options.model.language, options.model.uri);
+            }
+        }
+        this._editor = monaco.editor.create(this._editorContainer.nativeElement, options);
+        if (!hasModel) {
+            this._editor.setValue(this._value);
+        }
+        this._editor.onDidChangeModelContent((e) => {
+            const value = this._editor.getValue();
+            // value is not propagated to parent when executing outside zone.
+            this.zone.run(() => {
+                this.propagateChange(value);
+                this._value = value;
+            });
+        });
+        this._editor.onDidBlurEditorWidget(() => {
+            this.onTouched();
+        });
+        // refresh layout on resize event.
+        if (this._windowResizeSubscription) {
+            this._windowResizeSubscription.unsubscribe();
+        }
+        this._windowResizeSubscription = fromEvent(window, 'resize').subscribe(() => this._editor.layout());
+        this.onInit.emit(this._editor);
+    }
+}
+EditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EditorComponent, deps: [{ token: i0.NgZone }, { token: NGX_MONACO_EDITOR_CONFIG }], target: i0.ɵɵFactoryTarget.Component });
+EditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: EditorComponent, selector: "ngx-monaco-editor", inputs: { options: "options", model: "model" }, providers: [{
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => EditorComponent),
+            multi: true
+        }], usesInheritance: true, ngImport: i0, template: '<div class="editor-container" #editorContainer></div>', isInline: true, styles: ["\n      :host {\n          display: block;\n          height: 200px;\n      }\n\n      .editor-container {\n          width: 100%;\n          height: 98%;\n      }\n  "] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EditorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngx-monaco-editor',
+                    template: '<div class="editor-container" #editorContainer></div>',
+                    styles: [`
+      :host {
+          display: block;
+          height: 200px;
+      }
+
+      .editor-container {
+          width: 100%;
+          height: 98%;
+      }
+  `],
+                    providers: [{
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => EditorComponent),
+                            multi: true
+                        }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NGX_MONACO_EDITOR_CONFIG]
+                }] }]; }, propDecorators: { options: [{
+                type: Input,
+                args: ['options']
+            }], model: [{
+                type: Input,
+                args: ['model']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.component.js","sourceRoot":"","sources":["../../../../../src/app/modules/ngx-monaco-editor/editor.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAwB,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAEjC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,wBAAwB,EAAyB,MAAM,UAAU,CAAC;;AAyB3E,MAAM,OAAO,eAAgB,SAAQ,UAAU;IA4B7C,YAAoB,IAAY,EAA4C,YAAmC;QAC7G,KAAK,CAAC,YAAY,CAAC,CAAC;QADF,SAAI,GAAJ,IAAI,CAAQ;QAA4C,iBAAY,GAAZ,YAAY,CAAuB;QA3BvG,WAAM,GAAW,EAAE,CAAC;QAE5B,oBAAe,GAAG,CAAC,CAAM,EAAE,EAAE,GAAE,CAAC,CAAC;QACjC,cAAS,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IA0BrB,CAAC;IAxBD,IACI,OAAO,CAAC,OAAY;QACtB,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;QACvE,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACvB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;SAC1B;IACH,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,IACI,KAAK,CAAC,KAAqB;QAC7B,IAAI,CAAC,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;QAC3B,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACvB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SAC/B;IACH,CAAC;IAMD,UAAU,CAAC,KAAU;QACnB,IAAI,CAAC,MAAM,GAAG,KAAK,IAAI,EAAE,CAAC;QAC1B,iDAAiD;QACjD,UAAU,CAAC,GAAG,EAAE;YACd,IAAI,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;gBACvC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aACpC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB,CAAC,EAAO;QACtB,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;IAC5B,CAAC;IAED,iBAAiB,CAAC,EAAO;QACvB,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAES,UAAU,CAAC,OAAY;QAE/B,MAAM,QAAQ,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;QAEjC,IAAI,QAAQ,EAAE;YACZ,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC;YAC9D,IAAI,KAAK,EAAE;gBACT,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;gBACtB,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aACrC;iBAAM;gBACL,OAAO,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;aAC3G;SACF;QAED,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;QAElF,IAAI,CAAC,QAAQ,EAAE;YACb,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SACpC;QAED,IAAI,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAM,EAAE,EAAE;YAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;YAEtC,iEAAiE;YACjE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;gBACjB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;gBAC5B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACtB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,OAAO,CAAC,qBAAqB,CAAC,GAAG,EAAE;YACtC,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,CAAC,CAAC,CAAC;QAEH,kCAAkC;QAClC,IAAI,IAAI,CAAC,yBAAyB,EAAE;YAClC,IAAI,CAAC,yBAAyB,CAAC,WAAW,EAAE,CAAC;SAC9C;QACD,IAAI,CAAC,yBAAyB,GAAG,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QACpG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;;6GA1FU,eAAe,wCA4BgB,wBAAwB;iGA5BvD,eAAe,4FANf,CAAC;YACV,OAAO,EAAE,iBAAiB;YAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,eAAe,CAAC;YAC9C,KAAK,EAAE,IAAI;SACZ,CAAC,iDAhBQ,uDAAuD;4FAkBtD,eAAe;kBApB3B,SAAS;mBAAC;oBACT,QAAQ,EAAE,mBAAmB;oBAC7B,QAAQ,EAAE,uDAAuD;oBACjE,MAAM,EAAE,CAAC;;;;;;;;;;GAUR,CAAC;oBACF,SAAS,EAAE,CAAC;4BACV,OAAO,EAAE,iBAAiB;4BAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,gBAAgB,CAAC;4BAC9C,KAAK,EAAE,IAAI;yBACZ,CAAC;iBACH;;0BA6BoC,MAAM;2BAAC,wBAAwB;4CArB9D,OAAO;sBADV,KAAK;uBAAC,SAAS;gBAcZ,KAAK;sBADR,KAAK;uBAAC,OAAO","sourcesContent":["import { Component, forwardRef, Inject, Input, NgZone } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { fromEvent } from 'rxjs';\n\nimport { BaseEditor } from './base-editor';\nimport { NGX_MONACO_EDITOR_CONFIG, NgxMonacoEditorConfig } from './config';\nimport { NgxEditorModel } from './types';\n\ndeclare var monaco: any;\n\n@Component({\n  selector: 'ngx-monaco-editor',\n  template: '<div class=\"editor-container\" #editorContainer></div>',\n  styles: [`\n      :host {\n          display: block;\n          height: 200px;\n      }\n\n      .editor-container {\n          width: 100%;\n          height: 98%;\n      }\n  `],\n  providers: [{\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => EditorComponent),\n    multi: true\n  }]\n})\nexport class EditorComponent extends BaseEditor implements ControlValueAccessor {\n  private _value: string = '';\n\n  propagateChange = (_: any) => {};\n  onTouched = () => {};\n\n  @Input('options')\n  set options(options: any) {\n    this._options = Object.assign({}, this.config.defaultOptions, options);\n    if (this._editor) {\n      this._editor.dispose();\n      this.initMonaco(options);\n    }\n  }\n\n  get options(): any {\n    return this._options;\n  }\n\n  @Input('model')\n  set model(model: NgxEditorModel) {\n    this.options.model = model;\n    if (this._editor) {\n      this._editor.dispose();\n      this.initMonaco(this.options);\n    }\n  }\n\n  constructor(private zone: NgZone, @Inject(NGX_MONACO_EDITOR_CONFIG) private editorConfig: NgxMonacoEditorConfig) {\n    super(editorConfig);\n  }\n\n  writeValue(value: any): void {\n    this._value = value || '';\n    // Fix for value change while dispose in process.\n    setTimeout(() => {\n      if (this._editor && !this.options.model) {\n        this._editor.setValue(this._value);\n      }\n    });\n  }\n\n  registerOnChange(fn: any): void {\n    this.propagateChange = fn;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  protected initMonaco(options: any): void {\n\n    const hasModel = !!options.model;\n\n    if (hasModel) {\n      const model = monaco.editor.getModel(options.model.uri || '');\n      if (model) {\n        options.model = model;\n        options.model.setValue(this._value);\n      } else {\n        options.model = monaco.editor.createModel(options.model.value, options.model.language, options.model.uri);\n      }\n    }\n\n    this._editor = monaco.editor.create(this._editorContainer.nativeElement, options);\n\n    if (!hasModel) {\n      this._editor.setValue(this._value);\n    }\n\n    this._editor.onDidChangeModelContent((e: any) => {\n      const value = this._editor.getValue();\n\n      // value is not propagated to parent when executing outside zone.\n      this.zone.run(() => {\n        this.propagateChange(value);\n        this._value = value;\n      });\n    });\n\n    this._editor.onDidBlurEditorWidget(() => {\n      this.onTouched();\n    });\n\n    // refresh layout on resize event.\n    if (this._windowResizeSubscription) {\n      this._windowResizeSubscription.unsubscribe();\n    }\n    this._windowResizeSubscription = fromEvent(window, 'resize').subscribe(() => this._editor.layout());\n    this.onInit.emit(this._editor);\n  }\n\n}\n"]}

package/esm2015/app/modules/ngx-monaco-editor/editor.module.js

@@ -0,0 +1,40 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { NGX_MONACO_EDITOR_CONFIG } from './config';
+import { DiffEditorComponent } from './diff-editor.component';
+import { EditorComponent } from './editor.component';
+import * as i0 from "@angular/core";
+export class MonacoEditorModule {
+    static forRoot(config = {}) {
+        return {
+            ngModule: MonacoEditorModule,
+            providers: [
+                { provide: NGX_MONACO_EDITOR_CONFIG, useValue: config }
+            ]
+        };
+    }
+}
+MonacoEditorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MonacoEditorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MonacoEditorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MonacoEditorModule, declarations: [EditorComponent,
+        DiffEditorComponent], imports: [CommonModule], exports: [EditorComponent,
+        DiffEditorComponent] });
+MonacoEditorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MonacoEditorModule, imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MonacoEditorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule
+                    ],
+                    declarations: [
+                        EditorComponent,
+                        DiffEditorComponent
+                    ],
+                    exports: [
+                        EditorComponent,
+                        DiffEditorComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/modules/ngx-monaco-editor/types.js

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

package/fesm2015/firestitch-text-editor.js

@@ -1,10 +1,200 @@
 import * as i0 from '@angular/core';
-import { EventEmitter, forwardRef, Component, Inject, Input, Output, ViewChild, NgModule } from '@angular/core';
+import { InjectionToken, EventEmitter, Component, Inject, ViewChild, Output, forwardRef, Input, NgModule } from '@angular/core';
 import { DOCUMENT, CommonModule } from '@angular/common';
 import * as i2 from '@angular/forms';
 import { NG_VALUE_ACCESSOR, FormsModule } from '@angular/forms';
-import * as i1 from 'ngx-monaco-editor';
-import { EditorComponent, MonacoEditorModule } from 'ngx-monaco-editor';
+import { fromEvent } from 'rxjs';
+
+const NGX_MONACO_EDITOR_CONFIG = new InjectionToken('NGX_MONACO_EDITOR_CONFIG');
+
+let loadedMonaco = false;
+let loadPromise;
+class BaseEditor {
+    constructor(config) {
+        this.config = config;
+        this.onInit = new EventEmitter();
+    }
+    ngAfterViewInit() {
+        if (loadedMonaco) {
+            // Wait until monaco editor is available
+            loadPromise.then(() => {
+                this.initMonaco(this._options);
+            });
+        }
+        else {
+            loadedMonaco = true;
+            loadPromise = new Promise((resolve) => {
+                const baseUrl = (this.config.baseUrl || './assets') + '/monaco-editor/min/vs';
+                if (typeof (window.monaco) === 'object') {
+                    resolve();
+                    return;
+                }
+                const onGotAmdLoader = () => {
+                    // Load monaco
+                    window.require.config({ paths: { 'vs': `${baseUrl}` } });
+                    window.require([`vs/editor/editor.main`], () => {
+                        if (typeof this.config.onMonacoLoad === 'function') {
+                            this.config.onMonacoLoad();
+                        }
+                        this.initMonaco(this._options);
+                        resolve();
+                    });
+                };
+                // Load AMD loader if necessary
+                if (!window.require) {
+                    const loaderScript = document.createElement('script');
+                    loaderScript.type = 'text/javascript';
+                    loaderScript.src = `${baseUrl}/loader.js`;
+                    loaderScript.addEventListener('load', onGotAmdLoader);
+                    document.body.appendChild(loaderScript);
+                }
+                else {
+                    onGotAmdLoader();
+                }
+            });
+        }
+    }
+    ngOnDestroy() {
+        if (this._windowResizeSubscription) {
+            this._windowResizeSubscription.unsubscribe();
+        }
+        if (this._editor) {
+            this._editor.dispose();
+            this._editor = undefined;
+        }
+    }
+}
+BaseEditor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BaseEditor, deps: [{ token: NGX_MONACO_EDITOR_CONFIG }], target: i0.ɵɵFactoryTarget.Component });
+BaseEditor.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: BaseEditor, selector: "ng-component", outputs: { onInit: "onInit" }, viewQueries: [{ propertyName: "_editorContainer", first: true, predicate: ["editorContainer"], descendants: true, static: true }], ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BaseEditor, decorators: [{
+            type: Component,
+            args: [{
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NGX_MONACO_EDITOR_CONFIG]
+                }] }]; }, propDecorators: { _editorContainer: [{
+                type: ViewChild,
+                args: ['editorContainer', { static: true }]
+            }], onInit: [{
+                type: Output
+            }] } });
+
+class EditorComponent extends BaseEditor {
+    constructor(zone, editorConfig) {
+        super(editorConfig);
+        this.zone = zone;
+        this.editorConfig = editorConfig;
+        this._value = '';
+        this.propagateChange = (_) => { };
+        this.onTouched = () => { };
+    }
+    set options(options) {
+        this._options = Object.assign({}, this.config.defaultOptions, options);
+        if (this._editor) {
+            this._editor.dispose();
+            this.initMonaco(options);
+        }
+    }
+    get options() {
+        return this._options;
+    }
+    set model(model) {
+        this.options.model = model;
+        if (this._editor) {
+            this._editor.dispose();
+            this.initMonaco(this.options);
+        }
+    }
+    writeValue(value) {
+        this._value = value || '';
+        // Fix for value change while dispose in process.
+        setTimeout(() => {
+            if (this._editor && !this.options.model) {
+                this._editor.setValue(this._value);
+            }
+        });
+    }
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    initMonaco(options) {
+        const hasModel = !!options.model;
+        if (hasModel) {
+            const model = monaco.editor.getModel(options.model.uri || '');
+            if (model) {
+                options.model = model;
+                options.model.setValue(this._value);
+            }
+            else {
+                options.model = monaco.editor.createModel(options.model.value, options.model.language, options.model.uri);
+            }
+        }
+        this._editor = monaco.editor.create(this._editorContainer.nativeElement, options);
+        if (!hasModel) {
+            this._editor.setValue(this._value);
+        }
+        this._editor.onDidChangeModelContent((e) => {
+            const value = this._editor.getValue();
+            // value is not propagated to parent when executing outside zone.
+            this.zone.run(() => {
+                this.propagateChange(value);
+                this._value = value;
+            });
+        });
+        this._editor.onDidBlurEditorWidget(() => {
+            this.onTouched();
+        });
+        // refresh layout on resize event.
+        if (this._windowResizeSubscription) {
+            this._windowResizeSubscription.unsubscribe();
+        }
+        this._windowResizeSubscription = fromEvent(window, 'resize').subscribe(() => this._editor.layout());
+        this.onInit.emit(this._editor);
+    }
+}
+EditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EditorComponent, deps: [{ token: i0.NgZone }, { token: NGX_MONACO_EDITOR_CONFIG }], target: i0.ɵɵFactoryTarget.Component });
+EditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: EditorComponent, selector: "ngx-monaco-editor", inputs: { options: "options", model: "model" }, providers: [{
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => EditorComponent),
+            multi: true
+        }], usesInheritance: true, ngImport: i0, template: '<div class="editor-container" #editorContainer></div>', isInline: true, styles: ["\n      :host {\n          display: block;\n          height: 200px;\n      }\n\n      .editor-container {\n          width: 100%;\n          height: 98%;\n      }\n  "] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EditorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngx-monaco-editor',
+                    template: '<div class="editor-container" #editorContainer></div>',
+                    styles: [`
+      :host {
+          display: block;
+          height: 200px;
+      }
+
+      .editor-container {
+          width: 100%;
+          height: 98%;
+      }
+  `],
+                    providers: [{
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => EditorComponent),
+                            multi: true
+                        }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NGX_MONACO_EDITOR_CONFIG]
+                }] }]; }, propDecorators: { options: [{
+                type: Input,
+                args: ['options']
+            }], model: [{
+                type: Input,
+                args: ['model']
+            }] } });
 
 class FsTextEditorComponent {
     constructor(_element, _document) {
@@ -115,13 +305,13 @@ class FsTextEditorComponent {
         }, true);
     }
 }
-FsTextEditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FsTextEditorComponent, deps: [{ token: i0.ElementRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
-FsTextEditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: FsTextEditorComponent, selector: "fs-text-editor", inputs: { config: "config", scrollable: "scrollable" }, outputs: { init: "init", blur: "blur" }, providers: [{
+FsTextEditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FsTextEditorComponent, deps: [{ token: i0.ElementRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+FsTextEditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FsTextEditorComponent, selector: "fs-text-editor", inputs: { config: "config", scrollable: "scrollable" }, outputs: { init: "init", blur: "blur" }, providers: [{
             provide: NG_VALUE_ACCESSOR,
             useExisting: forwardRef(() => FsTextEditorComponent),
             multi: true
-        }], viewQueries: [{ propertyName: "_editorContainer", first: true, predicate: EditorComponent, descendants: true, static: true }], ngImport: i0, template: "<ngx-monaco-editor\n  [ngModel]=\"value\"\n  (ngModelChange)=\"changed($event)\"\n  [options]=\"config\"\n  (onInit)=\"onEditorInit($event)\">\n</ngx-monaco-editor>\n", styles: [":host ngx-monaco-editor{height:100%!important}:host ::ng-deep .decorationsOverviewRuler{display:none}:host ::ng-deep .margin,:host ::ng-deep .monaco-editor-background{top:0px!important}\n"], components: [{ type: i1.EditorComponent, selector: "ngx-monaco-editor", inputs: ["options", "model"] }], directives: [{ type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FsTextEditorComponent, decorators: [{
+        }], viewQueries: [{ propertyName: "_editorContainer", first: true, predicate: EditorComponent, descendants: true, static: true }], ngImport: i0, template: "<ngx-monaco-editor\n  [ngModel]=\"value\"\n  (ngModelChange)=\"changed($event)\"\n  [options]=\"config\"\n  (onInit)=\"onEditorInit($event)\">\n</ngx-monaco-editor>\n", styles: [":host ngx-monaco-editor{height:100%!important}:host ::ng-deep .decorationsOverviewRuler{display:none}:host ::ng-deep .margin,:host ::ng-deep .monaco-editor-background{top:0px!important}\n"], components: [{ type: EditorComponent, selector: "ngx-monaco-editor", inputs: ["options", "model"] }], directives: [{ type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FsTextEditorComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'fs-text-editor',
@@ -149,6 +339,126 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImpo
                 args: [EditorComponent, { static: true }]
             }] } });
 
+class DiffEditorComponent extends BaseEditor {
+    constructor(editorConfig) {
+        super(editorConfig);
+        this.editorConfig = editorConfig;
+    }
+    set options(options) {
+        this._options = Object.assign({}, this.config.defaultOptions, options);
+        if (this._editor) {
+            this._editor.dispose();
+            this.initMonaco(options);
+        }
+    }
+    get options() {
+        return this._options;
+    }
+    set originalModel(model) {
+        this._originalModel = model;
+        if (this._editor) {
+            this._editor.dispose();
+            this.initMonaco(this.options);
+        }
+    }
+    set modifiedModel(model) {
+        this._modifiedModel = model;
+        if (this._editor) {
+            this._editor.dispose();
+            this.initMonaco(this.options);
+        }
+    }
+    initMonaco(options) {
+        if (!this._originalModel || !this._modifiedModel) {
+            throw new Error('originalModel or modifiedModel not found for ngx-monaco-diff-editor');
+        }
+        this._originalModel.language = this._originalModel.language || options.language;
+        this._modifiedModel.language = this._modifiedModel.language || options.language;
+        let originalModel = monaco.editor.createModel(this._originalModel.code, this._originalModel.language);
+        let modifiedModel = monaco.editor.createModel(this._modifiedModel.code, this._modifiedModel.language);
+        this._editorContainer.nativeElement.innerHTML = '';
+        const theme = options.theme;
+        this._editor = monaco.editor.createDiffEditor(this._editorContainer.nativeElement, options);
+        options.theme = theme;
+        this._editor.setModel({
+            original: originalModel,
+            modified: modifiedModel
+        });
+        // refresh layout on resize event.
+        if (this._windowResizeSubscription) {
+            this._windowResizeSubscription.unsubscribe();
+        }
+        this._windowResizeSubscription = fromEvent(window, 'resize').subscribe(() => this._editor.layout());
+        this.onInit.emit(this._editor);
+    }
+}
+DiffEditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DiffEditorComponent, deps: [{ token: NGX_MONACO_EDITOR_CONFIG }], target: i0.ɵɵFactoryTarget.Component });
+DiffEditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: DiffEditorComponent, selector: "ngx-monaco-diff-editor", inputs: { options: "options", originalModel: "originalModel", modifiedModel: "modifiedModel" }, usesInheritance: true, ngImport: i0, template: '<div class="editor-container" #editorContainer></div>', isInline: true, styles: ["\n    :host {\n      display: block;\n      height: 200px;\n    }\n\n    .editor-container {\n      width: 100%;\n      height: 98%;\n    }\n  "] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DiffEditorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngx-monaco-diff-editor',
+                    template: '<div class="editor-container" #editorContainer></div>',
+                    styles: [`
+    :host {
+      display: block;
+      height: 200px;
+    }
+
+    .editor-container {
+      width: 100%;
+      height: 98%;
+    }
+  `]
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NGX_MONACO_EDITOR_CONFIG]
+                }] }]; }, propDecorators: { options: [{
+                type: Input,
+                args: ['options']
+            }], originalModel: [{
+                type: Input,
+                args: ['originalModel']
+            }], modifiedModel: [{
+                type: Input,
+                args: ['modifiedModel']
+            }] } });
+
+class MonacoEditorModule {
+    static forRoot(config = {}) {
+        return {
+            ngModule: MonacoEditorModule,
+            providers: [
+                { provide: NGX_MONACO_EDITOR_CONFIG, useValue: config }
+            ]
+        };
+    }
+}
+MonacoEditorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MonacoEditorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MonacoEditorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MonacoEditorModule, declarations: [EditorComponent,
+        DiffEditorComponent], imports: [CommonModule], exports: [EditorComponent,
+        DiffEditorComponent] });
+MonacoEditorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MonacoEditorModule, imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MonacoEditorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule
+                    ],
+                    declarations: [
+                        EditorComponent,
+                        DiffEditorComponent
+                    ],
+                    exports: [
+                        EditorComponent,
+                        DiffEditorComponent
+                    ]
+                }]
+        }] });
+
 class FsTextEditorModule {
     static forRoot(config) {
         return {
@@ -159,16 +469,16 @@ class FsTextEditorModule {
         };
     }
 }
-FsTextEditorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FsTextEditorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-FsTextEditorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FsTextEditorModule, declarations: [FsTextEditorComponent], imports: [CommonModule,
+FsTextEditorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FsTextEditorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FsTextEditorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FsTextEditorModule, declarations: [FsTextEditorComponent], imports: [CommonModule,
         MonacoEditorModule,
         FormsModule], exports: [FsTextEditorComponent] });
-FsTextEditorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FsTextEditorModule, imports: [[
+FsTextEditorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FsTextEditorModule, imports: [[
             CommonModule,
             MonacoEditorModule,
             FormsModule,
         ]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FsTextEditorModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FsTextEditorModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [