@firestitch/text-editor 12.3.0 → 12.4.0

package/esm2015/app/fs-text-editor.module.js

@@ -1,43 +1,43 @@
-import { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { FormsModule } from '@angular/forms';
-import { MonacoEditorModule } from 'ngx-monaco-editor';
-import { FsTextEditorComponent } from './components/text-editor/text-editor.component';
-import * as i0 from "@angular/core";
-export class FsTextEditorModule {
-    static forRoot(config) {
-        return {
-            ngModule: FsTextEditorModule,
-            providers: [
-                MonacoEditorModule.forRoot(config).providers,
-            ],
-        };
-    }
-}
-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,
-        MonacoEditorModule,
-        FormsModule], exports: [FsTextEditorComponent] });
-FsTextEditorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FsTextEditorModule, imports: [[
-            CommonModule,
-            MonacoEditorModule,
-            FormsModule,
-        ]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FsTextEditorModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        CommonModule,
-                        MonacoEditorModule,
-                        FormsModule,
-                    ],
-                    exports: [
-                        FsTextEditorComponent,
-                    ],
-                    entryComponents: [],
-                    declarations: [
-                        FsTextEditorComponent,
-                    ]
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { FsTextEditorComponent } from './components/text-editor/text-editor.component';
+import { MonacoEditorModule } from './modules/ngx-monaco-editor/editor.module';
+import * as i0 from "@angular/core";
+export class FsTextEditorModule {
+    static forRoot(config) {
+        return {
+            ngModule: FsTextEditorModule,
+            providers: [
+                MonacoEditorModule.forRoot(config).providers,
+            ],
+        };
+    }
+}
+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.17", ngImport: i0, type: FsTextEditorModule, imports: [[
+            CommonModule,
+            MonacoEditorModule,
+            FormsModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FsTextEditorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        MonacoEditorModule,
+                        FormsModule,
+                    ],
+                    exports: [
+                        FsTextEditorComponent,
+                    ],
+                    entryComponents: [],
+                    declarations: [
+                        FsTextEditorComponent,
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/interfaces/config.interface.js

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

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

@@ -0,0 +1,77 @@
+import { Component, ElementRef, EventEmitter, Inject, Output, ViewChild } from '@angular/core';
+import { NGX_MONACO_EDITOR_CONFIG } from './config';
+import * as i0 from "@angular/core";
+let loadedMonaco = false;
+let loadPromise;
+export 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
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1lZGl0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvbmd4LW1vbmFjby1lZGl0b3IvYmFzZS1lZGl0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFpQixTQUFTLEVBQUUsVUFBVSxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQWEsTUFBTSxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6SCxPQUFPLEVBQUUsd0JBQXdCLEVBQXlCLE1BQU0sVUFBVSxDQUFDOztBQUUzRSxJQUFJLFlBQVksR0FBRyxLQUFLLENBQUM7QUFDekIsSUFBSSxXQUEwQixDQUFDO0FBSy9CLE1BQU0sT0FBZ0IsVUFBVTtJQU85QixZQUF3RCxNQUE2QjtRQUE3QixXQUFNLEdBQU4sTUFBTSxDQUF1QjtRQUwzRSxXQUFNLEdBQUcsSUFBSSxZQUFZLEVBQU8sQ0FBQztJQUs2QyxDQUFDO0lBRXpGLGVBQWU7UUFDYixJQUFJLFlBQVksRUFBRTtZQUNoQix3Q0FBd0M7WUFDeEMsV0FBVyxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUU7Z0JBQ3BCLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQ2pDLENBQUMsQ0FBQyxDQUFDO1NBQ0o7YUFBTTtZQUNMLFlBQVksR0FBRyxJQUFJLENBQUM7WUFDcEIsV0FBVyxHQUFHLElBQUksT0FBTyxDQUFPLENBQUMsT0FBWSxFQUFFLEVBQUU7Z0JBQy9DLE1BQU0sT0FBTyxHQUFHLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLElBQUksVUFBVSxDQUFDLEdBQUcsdUJBQXVCLENBQUM7Z0JBQzlFLElBQUksT0FBTyxDQUFPLE1BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxRQUFRLEVBQUU7b0JBQzlDLE9BQU8sRUFBRSxDQUFDO29CQUNWLE9BQU87aUJBQ1I7Z0JBQ0QsTUFBTSxjQUFjLEdBQVEsR0FBRyxFQUFFO29CQUMvQixjQUFjO29CQUNSLE1BQU8sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQUUsS0FBSyxFQUFFLEVBQUUsSUFBSSxFQUFFLEdBQUcsT0FBTyxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUM7b0JBQzFELE1BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQyx1QkFBdUIsQ0FBQyxFQUFFLEdBQUcsRUFBRTt3QkFDcEQsSUFBSSxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsWUFBWSxLQUFLLFVBQVUsRUFBRTs0QkFDbEQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxZQUFZLEVBQUUsQ0FBQzt5QkFDNUI7d0JBQ0QsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7d0JBQy9CLE9BQU8sRUFBRSxDQUFDO29CQUNaLENBQUMsQ0FBQyxDQUFDO2dCQUNMLENBQUMsQ0FBQztnQkFFRiwrQkFBK0I7Z0JBQy9CLElBQUksQ0FBTyxNQUFPLENBQUMsT0FBTyxFQUFFO29CQUMxQixNQUFNLFlBQVksR0FBc0IsUUFBUSxDQUFDLGFBQWEsQ0FBQyxRQUFRLENBQUMsQ0FBQztvQkFDekUsWUFBWSxDQUFDLElBQUksR0FBRyxpQkFBaUIsQ0FBQztvQkFDdEMsWUFBWSxDQUFDLEdBQUcsR0FBRyxHQUFHLE9BQU8sWUFBWSxDQUFDO29CQUMxQyxZQUFZLENBQUMsZ0JBQWdCLENBQUMsTUFBTSxFQUFFLGNBQWMsQ0FBQyxDQUFDO29CQUN0RCxRQUFRLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxZQUFZLENBQUMsQ0FBQztpQkFDekM7cUJBQU07b0JBQ0wsY0FBYyxFQUFFLENBQUM7aUJBQ2xCO1lBQ0gsQ0FBQyxDQUFDLENBQUM7U0FDSjtJQUNILENBQUM7SUFJRCxXQUFXO1FBQ1QsSUFBSSxJQUFJLENBQUMseUJBQXlCLEVBQUU7WUFDbEMsSUFBSSxDQUFDLHlCQUF5QixDQUFDLFdBQVcsRUFBRSxDQUFDO1NBQzlDO1FBQ0QsSUFBSSxJQUFJLENBQUMsT0FBTyxFQUFFO1lBQ2hCLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDdkIsSUFBSSxDQUFDLE9BQU8sR0FBRyxTQUFTLENBQUM7U0FDMUI7SUFDSCxDQUFDOzt3R0EzRG1CLFVBQVUsa0JBT1Ysd0JBQXdCOzRGQVB4QixVQUFVLHNOQUZwQixFQUFFOzRGQUVRLFVBQVU7a0JBSC9CLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLEVBQUU7aUJBQ2I7OzBCQVFjLE1BQU07MkJBQUMsd0JBQXdCOzRDQU5JLGdCQUFnQjtzQkFBL0QsU0FBUzt1QkFBQyxpQkFBaUIsRUFBRSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUU7Z0JBQ3BDLE1BQU07c0JBQWYsTUFBTSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFmdGVyVmlld0luaXQsIENvbXBvbmVudCwgRWxlbWVudFJlZiwgRXZlbnRFbWl0dGVyLCBJbmplY3QsIE9uRGVzdHJveSwgT3V0cHV0LCBWaWV3Q2hpbGQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFN1YnNjcmlwdGlvbiB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgTkdYX01PTkFDT19FRElUT1JfQ09ORklHLCBOZ3hNb25hY29FZGl0b3JDb25maWcgfSBmcm9tICcuL2NvbmZpZyc7XG5cbmxldCBsb2FkZWRNb25hY28gPSBmYWxzZTtcbmxldCBsb2FkUHJvbWlzZTogUHJvbWlzZTx2b2lkPjtcblxuQENvbXBvbmVudCh7XG4gIHRlbXBsYXRlOiAnJ1xufSlcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBCYXNlRWRpdG9yIGltcGxlbWVudHMgQWZ0ZXJWaWV3SW5pdCwgT25EZXN0cm95IHtcbiAgQFZpZXdDaGlsZCgnZWRpdG9yQ29udGFpbmVyJywgeyBzdGF0aWM6IHRydWUgfSkgX2VkaXRvckNvbnRhaW5lcjogRWxlbWVudFJlZjtcbiAgQE91dHB1dCgpIG9uSW5pdCA9IG5ldyBFdmVudEVtaXR0ZXI8YW55PigpO1xuICBwcm90ZWN0ZWQgX2VkaXRvcjogYW55O1xuICBwcm90ZWN0ZWQgX29wdGlvbnM6IGFueTtcbiAgcHJvdGVjdGVkIF93aW5kb3dSZXNpemVTdWJzY3JpcHRpb246IFN1YnNjcmlwdGlvbjtcblxuICBjb25zdHJ1Y3RvcihASW5qZWN0KE5HWF9NT05BQ09fRURJVE9SX0NPTkZJRykgcHJvdGVjdGVkIGNvbmZpZzogTmd4TW9uYWNvRWRpdG9yQ29uZmlnKSB7fVxuXG4gIG5nQWZ0ZXJWaWV3SW5pdCgpOiB2b2lkIHtcbiAgICBpZiAobG9hZGVkTW9uYWNvKSB7XG4gICAgICAvLyBXYWl0IHVudGlsIG1vbmFjbyBlZGl0b3IgaXMgYXZhaWxhYmxlXG4gICAgICBsb2FkUHJvbWlzZS50aGVuKCgpID0+IHtcbiAgICAgICAgdGhpcy5pbml0TW9uYWNvKHRoaXMuX29wdGlvbnMpO1xuICAgICAgfSk7XG4gICAgfSBlbHNlIHtcbiAgICAgIGxvYWRlZE1vbmFjbyA9IHRydWU7XG4gICAgICBsb2FkUHJvbWlzZSA9IG5ldyBQcm9taXNlPHZvaWQ+KChyZXNvbHZlOiBhbnkpID0+IHtcbiAgICAgICAgY29uc3QgYmFzZVVybCA9ICh0aGlzLmNvbmZpZy5iYXNlVXJsIHx8ICcuL2Fzc2V0cycpICsgJy9tb25hY28tZWRpdG9yL21pbi92cyc7XG4gICAgICAgIGlmICh0eXBlb2YgKCg8YW55PndpbmRvdykubW9uYWNvKSA9PT0gJ29iamVjdCcpIHtcbiAgICAgICAgICByZXNvbHZlKCk7XG4gICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG4gICAgICAgIGNvbnN0IG9uR290QW1kTG9hZGVyOiBhbnkgPSAoKSA9PiB7XG4gICAgICAgICAgLy8gTG9hZCBtb25hY29cbiAgICAgICAgICAoPGFueT53aW5kb3cpLnJlcXVpcmUuY29uZmlnKHsgcGF0aHM6IHsgJ3ZzJzogYCR7YmFzZVVybH1gIH0gfSk7XG4gICAgICAgICAgKDxhbnk+d2luZG93KS5yZXF1aXJlKFtgdnMvZWRpdG9yL2VkaXRvci5tYWluYF0sICgpID0+IHtcbiAgICAgICAgICAgIGlmICh0eXBlb2YgdGhpcy5jb25maWcub25Nb25hY29Mb2FkID09PSAnZnVuY3Rpb24nKSB7XG4gICAgICAgICAgICAgIHRoaXMuY29uZmlnLm9uTW9uYWNvTG9hZCgpO1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgdGhpcy5pbml0TW9uYWNvKHRoaXMuX29wdGlvbnMpO1xuICAgICAgICAgICAgcmVzb2x2ZSgpO1xuICAgICAgICAgIH0pO1xuICAgICAgICB9O1xuXG4gICAgICAgIC8vIExvYWQgQU1EIGxvYWRlciBpZiBuZWNlc3NhcnlcbiAgICAgICAgaWYgKCEoPGFueT53aW5kb3cpLnJlcXVpcmUpIHtcbiAgICAgICAgICBjb25zdCBsb2FkZXJTY3JpcHQ6IEhUTUxTY3JpcHRFbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnc2NyaXB0Jyk7XG4gICAgICAgICAgbG9hZGVyU2NyaXB0LnR5cGUgPSAndGV4dC9qYXZhc2NyaXB0JztcbiAgICAgICAgICBsb2FkZXJTY3JpcHQuc3JjID0gYCR7YmFzZVVybH0vbG9hZGVyLmpzYDtcbiAgICAgICAgICBsb2FkZXJTY3JpcHQuYWRkRXZlbnRMaXN0ZW5lcignbG9hZCcsIG9uR290QW1kTG9hZGVyKTtcbiAgICAgICAgICBkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGxvYWRlclNjcmlwdCk7XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgb25Hb3RBbWRMb2FkZXIoKTtcbiAgICAgICAgfVxuICAgICAgfSk7XG4gICAgfVxuICB9XG5cbiAgcHJvdGVjdGVkIGFic3RyYWN0IGluaXRNb25hY28ob3B0aW9uczogYW55KTogdm9pZDtcblxuICBuZ09uRGVzdHJveSgpIHtcbiAgICBpZiAodGhpcy5fd2luZG93UmVzaXplU3Vic2NyaXB0aW9uKSB7XG4gICAgICB0aGlzLl93aW5kb3dSZXNpemVTdWJzY3JpcHRpb24udW5zdWJzY3JpYmUoKTtcbiAgICB9XG4gICAgaWYgKHRoaXMuX2VkaXRvcikge1xuICAgICAgdGhpcy5fZWRpdG9yLmRpc3Bvc2UoKTtcbiAgICAgIHRoaXMuX2VkaXRvciA9IHVuZGVmaW5lZDtcbiAgICB9XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const NGX_MONACO_EDITOR_CONFIG = new InjectionToken('NGX_MONACO_EDITOR_CONFIG');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9tb2R1bGVzL25neC1tb25hY28tZWRpdG9yL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFHLElBQUksY0FBYyxDQUFDLDBCQUEwQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgY29uc3QgTkdYX01PTkFDT19FRElUT1JfQ09ORklHID0gbmV3IEluamVjdGlvblRva2VuKCdOR1hfTU9OQUNPX0VESVRPUl9DT05GSUcnKTtcblxuZXhwb3J0IGludGVyZmFjZSBOZ3hNb25hY29FZGl0b3JDb25maWcge1xuICBiYXNlVXJsPzogc3RyaW5nO1xuICBkZWZhdWx0T3B0aW9ucz86IHsgW2tleTogc3RyaW5nXTogYW55OyB9O1xuICBvbk1vbmFjb0xvYWQ/OiBGdW5jdGlvbjtcbn1cbiJdfQ==

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

@@ -0,0 +1,91 @@
+import { Component, Inject, Input } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { BaseEditor } from './base-editor';
+import { NGX_MONACO_EDITOR_CONFIG } from './config';
+import * as i0 from "@angular/core";
+export 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']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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":"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","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/esm2015/firestitch-text-editor.js

@@ -1,5 +1,5 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './public_api';
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlyZXN0aXRjaC10ZXh0LWVkaXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maXJlc3RpdGNoLXRleHQtZWRpdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=

package/esm2015/public_api.js

@@ -1,6 +1,6 @@
-/*
- * Public API Surface of fs-menu
- */
-export { FsTextEditorModule } from './app/fs-text-editor.module';
-export { FsTextEditorComponent } from './app/components/text-editor/text-editor.component';
+/*
+ * Public API Surface of fs-menu
+ */
+export { FsTextEditorModule } from './app/fs-text-editor.module';
+export { FsTextEditorComponent } from './app/components/text-editor/text-editor.component';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBSUgsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFLakUsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sb0RBQW9ELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGZzLW1lbnVcbiAqL1xuXG5pbXBvcnQgeyBmcm9tIH0gZnJvbSAncnhqcyc7XG5cbmV4cG9ydCB7IEZzVGV4dEVkaXRvck1vZHVsZSB9IGZyb20gJy4vYXBwL2ZzLXRleHQtZWRpdG9yLm1vZHVsZSc7XG5cbmV4cG9ydCB7IEZzVGV4dEVkaXRvckNvbmZpZyB9IGZyb20gJy4vYXBwL2ludGVyZmFjZXMvY29uZmlnLmludGVyZmFjZSc7XG5cblxuZXhwb3J0IHsgRnNUZXh0RWRpdG9yQ29tcG9uZW50IH0gZnJvbSAnLi9hcHAvY29tcG9uZW50cy90ZXh0LWVkaXRvci90ZXh0LWVkaXRvci5jb21wb25lbnQnO1xuIl19