@firestitch/text-editor 18.0.2 → 18.0.4

package/app/components/text-editor/text-editor.component.d.ts

@@ -1,9 +1,8 @@
-import { EventEmitter, OnInit } from '@angular/core';
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import { FsTextEditorConfig } from '../../interfaces/config.interface';
 import * as i0 from "@angular/core";
-export declare class FsTextEditorComponent implements OnInit, ControlValueAccessor {
-    private _document;
+export declare class FsTextEditorComponent implements OnInit, ControlValueAccessor, OnDestroy {
     readonly LINE_HEIGHT = 18;
     config: FsTextEditorConfig;
     scrollable: boolean;
@@ -14,7 +13,9 @@ export declare class FsTextEditorComponent implements OnInit, ControlValueAccess
     private _editorRef;
     private _value;
     private _window;
-    constructor(_document: Document);
+    private _document;
+    private _elementRef;
+    constructor();
     get monaco(): any;
     ngOnInit(): void;
     get value(): string;
@@ -24,10 +25,10 @@ export declare class FsTextEditorComponent implements OnInit, ControlValueAccess
     updateLayout(): void;
     registerOnChange(fn: any): void;
     registerOnTouched(fn: any): void;
+    ngOnDestroy(): void;
     private _initEditor;
     private _updateEditorHeight;
     private _disableScroll;
-    private _cleanupAMDLoader;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsTextEditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FsTextEditorComponent, "fs-text-editor", never, { "config": "config"; "scrollable": "scrollable"; }, { "ready": "ready"; "blur": "blur"; }, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FsTextEditorComponent, "fs-text-editor", never, { "config": { "alias": "config"; "required": false; }; "scrollable": { "alias": "scrollable"; "required": false; }; }, { "ready": "ready"; "blur": "blur"; }, never, never, true, never>;
 }

package/app/fs-text-editor.module.d.ts

@@ -1,13 +1,13 @@
 import { ModuleWithProviders } from '@angular/core';
 import { NgxMonacoEditorConfig } from './modules/ngx-monaco-editor/config';
 import * as i0 from "@angular/core";
-import * as i1 from "./components/text-editor/text-editor.component";
-import * as i2 from "@angular/common";
-import * as i3 from "./modules/ngx-monaco-editor/editor.module";
-import * as i4 from "@angular/forms";
+import * as i1 from "@angular/common";
+import * as i2 from "./modules/ngx-monaco-editor/editor.module";
+import * as i3 from "@angular/forms";
+import * as i4 from "./components/text-editor/text-editor.component";
 export declare class FsTextEditorModule {
     static forRoot(config?: NgxMonacoEditorConfig): ModuleWithProviders<FsTextEditorModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsTextEditorModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<FsTextEditorModule, [typeof i1.FsTextEditorComponent], [typeof i2.CommonModule, typeof i3.MonacoEditorModule, typeof i4.FormsModule], [typeof i1.FsTextEditorComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FsTextEditorModule, never, [typeof i1.CommonModule, typeof i2.MonacoEditorModule, typeof i3.FormsModule, typeof i4.FsTextEditorComponent], [typeof i4.FsTextEditorComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<FsTextEditorModule>;
 }

package/app/interfaces/config.interface.d.ts

@@ -1,7 +1,9 @@
 import { editor } from 'monaco-editor';
 export interface FsTextEditorConfig extends editor.IStandaloneEditorConstructionOptions {
     height?: any;
-    ready?: (editor: editor.ICodeEditor) => void;
+    ready?: (editor: editor.ICodeEditor, monaco: any) => void;
+    destroy?: (editor: editor.ICodeEditor, monaco: any) => void;
     blur?: () => void;
     focus?: () => void;
+    minHeight?: number;
 }

package/app/modules/ngx-monaco-editor/base-editor.d.ts

@@ -1,19 +1,17 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
 import { Subscription } from 'rxjs';
 import { editor } from 'monaco-editor';
-import { NgxMonacoEditorConfig } from './config';
 import * as i0 from "@angular/core";
 export declare abstract class BaseEditor implements AfterViewInit, OnDestroy {
-    protected config: NgxMonacoEditorConfig;
     _editorContainer: ElementRef;
     onInit: EventEmitter<any>;
     protected _editor: editor.ICodeEditor;
     protected _options: any;
     protected _windowResizeSubscription: Subscription;
-    constructor(config: NgxMonacoEditorConfig);
+    config: import("./config").NgxMonacoEditorConfig;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     protected abstract initMonaco(options: any): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BaseEditor, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BaseEditor, "ng-component", never, {}, { "onInit": "onInit"; }, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseEditor, "ng-component", never, {}, { "onInit": "onInit"; }, never, never, false, never>;
 }

package/app/modules/ngx-monaco-editor/config.d.ts

@@ -1,5 +1,5 @@
 import { InjectionToken } from '@angular/core';
-export declare const NGX_MONACO_EDITOR_CONFIG: InjectionToken<unknown>;
+export declare const NGX_MONACO_EDITOR_CONFIG: InjectionToken<NgxMonacoEditorConfig>;
 export interface NgxMonacoEditorConfig {
     baseUrl?: string;
     defaultOptions?: {

package/app/modules/ngx-monaco-editor/diff-editor.component.d.ts

@@ -1,17 +1,14 @@
 import { BaseEditor } from './base-editor';
-import { NgxMonacoEditorConfig } from './config';
 import { DiffEditorModel } from './types';
 import * as i0 from "@angular/core";
 export declare class DiffEditorComponent extends BaseEditor {
-    private editorConfig;
-    _originalModel: DiffEditorModel;
-    _modifiedModel: DiffEditorModel;
+    private _originalModel;
+    private _modifiedModel;
     set options(options: any);
     get options(): any;
     set originalModel(model: DiffEditorModel);
     set modifiedModel(model: DiffEditorModel);
-    constructor(editorConfig: NgxMonacoEditorConfig);
     protected initMonaco(options: any): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DiffEditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DiffEditorComponent, "ngx-monaco-diff-editor", never, { "options": "options"; "originalModel": "originalModel"; "modifiedModel": "modifiedModel"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DiffEditorComponent, "ngx-monaco-diff-editor", never, { "options": { "alias": "options"; "required": false; }; "originalModel": { "alias": "originalModel"; "required": false; }; "modifiedModel": { "alias": "modifiedModel"; "required": false; }; }, {}, never, never, true, never>;
 }

package/app/modules/ngx-monaco-editor/editor.component.d.ts

@@ -1,7 +1,5 @@
-import { NgZone } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import { BaseEditor } from './base-editor';
-import { NgxMonacoEditorConfig } from './config';
 import { NgxEditorModel } from './types';
 import * as i0 from "@angular/core";
 export declare class EditorComponent extends BaseEditor implements ControlValueAccessor {
@@ -13,11 +11,10 @@ export declare class EditorComponent extends BaseEditor implements ControlValueA
     set options(options: any);
     get options(): any;
     set model(model: NgxEditorModel);
-    constructor(zone: NgZone, editorConfig: NgxMonacoEditorConfig);
     writeValue(value: any): void;
     registerOnChange(fn: any): void;
     registerOnTouched(fn: any): void;
     protected initMonaco(options: any): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<EditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<EditorComponent, "ngx-monaco-editor", never, { "options": "options"; "model": "model"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorComponent, "ngx-monaco-editor", never, { "options": { "alias": "options"; "required": false; }; "model": { "alias": "model"; "required": false; }; }, {}, never, never, true, never>;
 }

package/app/modules/ngx-monaco-editor/editor.module.d.ts

@@ -1,12 +1,12 @@
 import { ModuleWithProviders } from '@angular/core';
 import { NgxMonacoEditorConfig } from './config';
 import * as i0 from "@angular/core";
-import * as i1 from "./editor.component";
-import * as i2 from "./diff-editor.component";
-import * as i3 from "@angular/common";
+import * as i1 from "@angular/common";
+import * as i2 from "./editor.component";
+import * as i3 from "./diff-editor.component";
 export declare class MonacoEditorModule {
     static forRoot(config?: NgxMonacoEditorConfig): ModuleWithProviders<MonacoEditorModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<MonacoEditorModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<MonacoEditorModule, [typeof i1.EditorComponent, typeof i2.DiffEditorComponent], [typeof i3.CommonModule], [typeof i1.EditorComponent, typeof i2.DiffEditorComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MonacoEditorModule, never, [typeof i1.CommonModule, typeof i2.EditorComponent, typeof i3.DiffEditorComponent], [typeof i2.EditorComponent, typeof i3.DiffEditorComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<MonacoEditorModule>;
 }

package/esm2022/app/components/text-editor/text-editor.component.mjs

@@ -0,0 +1,158 @@
+import { DOCUMENT } from '@angular/common';
+import { Component, ElementRef, EventEmitter, Input, Output, forwardRef, inject } from '@angular/core';
+import { FormsModule, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { EditorComponent } from '../../modules/ngx-monaco-editor/editor.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class FsTextEditorComponent {
+    LINE_HEIGHT = 18;
+    config = {};
+    scrollable = false;
+    ready = new EventEmitter();
+    blur = new EventEmitter();
+    onChange;
+    onTouched;
+    _editorRef;
+    _value = '';
+    _window;
+    _document = inject(DOCUMENT);
+    _elementRef = inject(ElementRef);
+    constructor() {
+        this._window = this._document.defaultView;
+    }
+    get monaco() {
+        return this._window.monaco;
+    }
+    ngOnInit() {
+        if (this.config) {
+            this.config = {
+                minimap: {
+                    enabled: false,
+                },
+                minHeight: this.config.minHeight ?? 150,
+                theme: 'vs-dark',
+                automaticLayout: !!this.config.height,
+                scrollBeyondLastLine: false,
+                scrollbar: {
+                    vertical: this.config.height ? 'auto' : 'hidden',
+                },
+                hideCursorInOverviewRuler: true,
+                ...this.config,
+            };
+        }
+        if (this.config.minHeight) {
+            this._elementRef.nativeElement.style
+                .setProperty('--min-height', `${this.config.minHeight}px`);
+        }
+    }
+    get value() {
+        return this._value;
+    }
+    onEditorInit(event) {
+        // Timeout allows the content to fully load to and calculate height
+        setTimeout(() => {
+            this._editorRef = event;
+            this._initEditor();
+            this.ready.next(event);
+            if (!this.scrollable && !this.config.height) {
+                this._disableScroll();
+            }
+            if (this.config.ready) {
+                this.config.ready(this._editorRef, this.monaco);
+            }
+        });
+        // moved forward for cases when several editors should be initialized on the same page
+        // setTimeout(() => {
+        //   this._cleanupAMDLoader();
+        // }, 100);
+    }
+    writeValue(value) {
+        this._value = value || '';
+    }
+    changed(e) {
+        if (this._value !== e) {
+            this._value = e;
+            this.onChange(e);
+        }
+    }
+    updateLayout() {
+        this._editorRef.layout();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    ngOnDestroy() {
+        if (this.config.destroy) {
+            this.config.destroy(this._editorRef, this.monaco);
+        }
+    }
+    _initEditor() {
+        if (this._editorRef && !this.config.height) {
+            this._updateEditorHeight();
+            this._editorRef.onDidChangeModelContent(() => {
+                this._updateEditorHeight();
+            });
+        }
+        this._editorRef.onDidBlurEditorText(() => {
+            this.blur.next(null);
+            if (this.config.blur) {
+                this.config.blur();
+            }
+        });
+        this._editorRef.onDidFocusEditorText(() => {
+            if (this.config.focus) {
+                this.config.focus();
+            }
+        });
+    }
+    _updateEditorHeight() {
+        const editorDomNode = this._editorRef.getDomNode();
+        if (!editorDomNode) {
+            return;
+        }
+        const container = editorDomNode.getElementsByClassName('view-lines')[0];
+        const lineHeight = container.firstChild
+            ? container.firstChild.offsetHeight
+            : this.LINE_HEIGHT;
+        const editorModel = this._editorRef.getModel();
+        if (!editorModel) {
+            return;
+        }
+        const nextHeight = this._editorRef.getModel().getLineCount() * lineHeight;
+        // set the height and redo layout
+        editorDomNode.style.height = `${nextHeight}px`;
+        this.updateLayout();
+    }
+    _disableScroll() {
+        const node = this._editorRef.getDomNode();
+        node.addEventListener('wheel', (e) => {
+            e.stopPropagation();
+        }, true);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: FsTextEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.7", type: FsTextEditorComponent, isStandalone: true, selector: "fs-text-editor", inputs: { config: "config", scrollable: "scrollable" }, outputs: { ready: "ready", blur: "blur" }, providers: [{
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => FsTextEditorComponent),
+                multi: 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>", styles: ["ngx-monaco-editor{display:block}ngx-monaco-editor ::ng-deep .monaco-editor{min-height:var(--min-height)}\n"], dependencies: [{ kind: "component", type: EditorComponent, selector: "ngx-monaco-editor", inputs: ["options", "model"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: FsTextEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'fs-text-editor', providers: [{
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => FsTextEditorComponent),
+                            multi: true,
+                        }], standalone: true, imports: [EditorComponent, FormsModule], template: "<ngx-monaco-editor\n  [ngModel]=\"value\"\n  (ngModelChange)=\"changed($event)\"\n  [options]=\"config\"\n  (onInit)=\"onEditorInit($event)\">\n</ngx-monaco-editor>", styles: ["ngx-monaco-editor{display:block}ngx-monaco-editor ::ng-deep .monaco-editor{min-height:var(--min-height)}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { config: [{
+                type: Input
+            }], scrollable: [{
+                type: Input
+            }], ready: [{
+                type: Output
+            }], blur: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text-editor.component.js","sourceRoot":"","sources":["../../../../../src/app/components/text-editor/text-editor.component.ts","../../../../../src/app/components/text-editor/text-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport { Component, ElementRef, EventEmitter, Input, OnDestroy, OnInit, Output, forwardRef, inject } from '@angular/core';\nimport { ControlValueAccessor, FormsModule, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport { editor } from 'monaco-editor';\n\nimport { FsTextEditorConfig } from '../../interfaces/config.interface';\nimport { EditorComponent } from '../../modules/ngx-monaco-editor/editor.component';\n\n\n@Component({\n  selector: 'fs-text-editor',\n  templateUrl: './text-editor.component.html',\n  styleUrls: ['./text-editor.component.scss'],\n  providers: [{\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => FsTextEditorComponent),\n    multi: true,\n  }],\n  standalone: true,\n  imports: [EditorComponent, FormsModule],\n})\nexport class FsTextEditorComponent implements OnInit, ControlValueAccessor, OnDestroy {\n\n  public readonly LINE_HEIGHT = 18;\n\n  @Input() public config: FsTextEditorConfig = {};\n  @Input() public scrollable = false;\n\n  @Output() public ready = new EventEmitter();\n  @Output() public blur = new EventEmitter();\n\n  public onChange: (_: any) => void;\n  public onTouched: () => void;\n\n  private _editorRef: editor.ICodeEditor;\n  private _value = '';\n  private _window: any;  \n  private _document = inject<Document>(DOCUMENT);\n  private _elementRef = inject(ElementRef);\n\n  constructor() {\n    this._window = this._document.defaultView;\n  }\n\n  public get monaco() {\n    return this._window.monaco;\n  }\n\n  public ngOnInit() {\n    if (this.config) {\n      this.config = {\n        minimap: {\n          enabled: false,\n        },\n        minHeight: this.config.minHeight ?? 150,\n        theme: 'vs-dark',\n        automaticLayout: !!this.config.height,\n        scrollBeyondLastLine: false,\n        scrollbar: {\n          vertical: this.config.height ? 'auto' : 'hidden',\n        },\n        hideCursorInOverviewRuler: true,\n        ...this.config,\n      };\n    }\n    \n    if (this.config.minHeight) {\n      this._elementRef.nativeElement.style\n        .setProperty('--min-height', `${this.config.minHeight}px`);\n    }\n  }\n\n  public get value() {\n    return this._value;\n  }\n\n  public onEditorInit(event) {\n    // Timeout allows the content to fully load to and calculate height\n    setTimeout(() => {\n      this._editorRef = event;\n      this._initEditor();\n      this.ready.next(event);\n\n      if (!this.scrollable && !this.config.height) {\n        this._disableScroll();\n      }\n\n      if(this.config.ready) {\n        this.config.ready(this._editorRef, this.monaco);\n      }\n    });\n\n    // moved forward for cases when several editors should be initialized on the same page\n    // setTimeout(() => {\n    //   this._cleanupAMDLoader();\n    // }, 100);\n  }\n\n  public writeValue(value: any): void {\n    this._value = value || '';\n  }\n\n  public changed(e) {\n    if (this._value !== e) {\n      this._value = e;\n      this.onChange(e);\n    }\n  }\n\n  public updateLayout(): void {\n    this._editorRef.layout();\n  }\n\n  public registerOnChange(fn: any): void {\n    this.onChange = fn;\n  }\n\n  public registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  public ngOnDestroy(): void {\n    if(this.config.destroy) {\n      this.config.destroy(this._editorRef, this.monaco);\n    }\n  }\n\n  private _initEditor() {\n    if (this._editorRef && !this.config.height) {\n      this._updateEditorHeight();\n\n      this._editorRef.onDidChangeModelContent(() => {\n        this._updateEditorHeight();\n      });\n    }\n\n    this._editorRef.onDidBlurEditorText(() => {\n      this.blur.next(null);\n      if(this.config.blur) {\n        this.config.blur();\n      }\n    });\n\n    this._editorRef.onDidFocusEditorText(() => {\n      if(this.config.focus) {\n        this.config.focus();\n      }\n    });\n  }\n\n  private _updateEditorHeight() {\n    const editorDomNode = this._editorRef.getDomNode();\n\n    if (!editorDomNode) {\n      return;\n    }\n\n    const container = editorDomNode.getElementsByClassName('view-lines')[0] as HTMLElement;\n    const lineHeight = container.firstChild\n      ? (container.firstChild as HTMLElement).offsetHeight\n      : this.LINE_HEIGHT;\n\n    const editorModel = this._editorRef.getModel();\n\n    if (!editorModel) {\n      return;\n    }\n\n    const nextHeight = this._editorRef.getModel().getLineCount() * lineHeight;\n\n    // set the height and redo layout\n    editorDomNode.style.height = `${nextHeight  }px`;\n    this.updateLayout();\n  }\n\n  private _disableScroll() {\n    const node = this._editorRef.getDomNode();\n\n    node.addEventListener('wheel', (e) => {\n      e.stopPropagation();\n    }, true);\n  }\n}\n","<ngx-monaco-editor\n  [ngModel]=\"value\"\n  (ngModelChange)=\"changed($event)\"\n  [options]=\"config\"\n  (onInit)=\"onEditorInit($event)\">\n</ngx-monaco-editor>"]}

package/esm2022/app/fs-text-editor.module.mjs

@@ -0,0 +1,40 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+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,
+            ],
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: FsTextEditorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.7", ngImport: i0, type: FsTextEditorModule, imports: [CommonModule,
+            MonacoEditorModule,
+            FormsModule,
+            FsTextEditorComponent], exports: [FsTextEditorComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: FsTextEditorModule, imports: [CommonModule,
+            MonacoEditorModule,
+            FormsModule,
+            FsTextEditorComponent] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: FsTextEditorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        MonacoEditorModule,
+                        FormsModule,
+                        FsTextEditorComponent,
+                    ],
+                    exports: [
+                        FsTextEditorComponent,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnMtdGV4dC1lZGl0b3IubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcC9mcy10ZXh0LWVkaXRvci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBdUIsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzlELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUU3QyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxnREFBZ0QsQ0FBQztBQUV2RixPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQzs7QUFjL0UsTUFBTSxPQUFPLGtCQUFrQjtJQUN0QixNQUFNLENBQUMsT0FBTyxDQUFDLE1BQThCO1FBQ2xELE9BQU87WUFDTCxRQUFRLEVBQUUsa0JBQWtCO1lBQzVCLFNBQVMsRUFBRTtnQkFDVCxrQkFBa0IsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUMsU0FBUzthQUM3QztTQUNGLENBQUM7SUFDSixDQUFDO3VHQVJVLGtCQUFrQjt3R0FBbEIsa0JBQWtCLFlBVDNCLFlBQVk7WUFDWixrQkFBa0I7WUFDbEIsV0FBVztZQUNYLHFCQUFxQixhQUdyQixxQkFBcUI7d0dBR1osa0JBQWtCLFlBVDNCLFlBQVk7WUFDWixrQkFBa0I7WUFDbEIsV0FBVztZQUNYLHFCQUFxQjs7MkZBTVosa0JBQWtCO2tCQVg5QixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRTt3QkFDUCxZQUFZO3dCQUNaLGtCQUFrQjt3QkFDbEIsV0FBVzt3QkFDWCxxQkFBcUI7cUJBQ3RCO29CQUNELE9BQU8sRUFBRTt3QkFDUCxxQkFBcUI7cUJBQ3RCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE1vZHVsZVdpdGhQcm92aWRlcnMsIE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb3Jtc01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuaW1wb3J0IHsgRnNUZXh0RWRpdG9yQ29tcG9uZW50IH0gZnJvbSAnLi9jb21wb25lbnRzL3RleHQtZWRpdG9yL3RleHQtZWRpdG9yLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBOZ3hNb25hY29FZGl0b3JDb25maWcgfSBmcm9tICcuL21vZHVsZXMvbmd4LW1vbmFjby1lZGl0b3IvY29uZmlnJztcbmltcG9ydCB7IE1vbmFjb0VkaXRvck1vZHVsZSB9IGZyb20gJy4vbW9kdWxlcy9uZ3gtbW9uYWNvLWVkaXRvci9lZGl0b3IubW9kdWxlJztcblxuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIE1vbmFjb0VkaXRvck1vZHVsZSxcbiAgICBGb3Jtc01vZHVsZSxcbiAgICBGc1RleHRFZGl0b3JDb21wb25lbnQsXG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBGc1RleHRFZGl0b3JDb21wb25lbnQsXG4gIF0sXG59KVxuZXhwb3J0IGNsYXNzIEZzVGV4dEVkaXRvck1vZHVsZSB7XG4gIHB1YmxpYyBzdGF0aWMgZm9yUm9vdChjb25maWc/OiBOZ3hNb25hY29FZGl0b3JDb25maWcpOiBNb2R1bGVXaXRoUHJvdmlkZXJzPEZzVGV4dEVkaXRvck1vZHVsZT4ge1xuICAgIHJldHVybiB7XG4gICAgICBuZ01vZHVsZTogRnNUZXh0RWRpdG9yTW9kdWxlLFxuICAgICAgcHJvdmlkZXJzOiBbXG4gICAgICAgIE1vbmFjb0VkaXRvck1vZHVsZS5mb3JSb290KGNvbmZpZykucHJvdmlkZXJzLFxuICAgICAgXSxcbiAgICB9O1xuICB9XG59XG4iXX0=

package/{esm2020 → esm2022}/app/interfaces/config.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcHAvaW50ZXJmYWNlcy9jb25maWcuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBlZGl0b3IgfSBmcm9tICdtb25hY28tZWRpdG9yJztcblxuZXhwb3J0IGludGVyZmFjZSBGc1RleHRFZGl0b3JDb25maWcgZXh0ZW5kcyBlZGl0b3IuSVN0YW5kYWxvbmVFZGl0b3JDb25zdHJ1Y3Rpb25PcHRpb25zIHtcbiAgaGVpZ2h0PzogYW55O1xuICByZWFkeT86IChlZGl0b3I6IGVkaXRvci5JQ29kZUVkaXRvcikgPT4gdm9pZDtcbiAgYmx1cj86ICgpID0+IHZvaWQ7XG4gIGZvY3VzPzogKCkgPT4gdm9pZDtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcHAvaW50ZXJmYWNlcy9jb25maWcuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBlZGl0b3IgfSBmcm9tICdtb25hY28tZWRpdG9yJztcblxuZXhwb3J0IGludGVyZmFjZSBGc1RleHRFZGl0b3JDb25maWcgZXh0ZW5kcyBlZGl0b3IuSVN0YW5kYWxvbmVFZGl0b3JDb25zdHJ1Y3Rpb25PcHRpb25zIHtcbiAgaGVpZ2h0PzogYW55O1xuICByZWFkeT86IChlZGl0b3I6IGVkaXRvci5JQ29kZUVkaXRvciwgbW9uYWNvOiBhbnkpID0+IHZvaWQ7XG4gIGRlc3Ryb3k/OiAoZWRpdG9yOiBlZGl0b3IuSUNvZGVFZGl0b3IsIG1vbmFjbzogYW55KSA9PiB2b2lkO1xuICBibHVyPzogKCkgPT4gdm9pZDtcbiAgZm9jdXM/OiAoKSA9PiB2b2lkO1xuICBtaW5IZWlnaHQ/OiBudW1iZXI7XG59XG4iXX0=

package/esm2022/app/modules/ngx-monaco-editor/base-editor.mjs

@@ -0,0 +1,75 @@
+import { Component, ElementRef, EventEmitter, Output, ViewChild, inject } from '@angular/core';
+import { NGX_MONACO_EDITOR_CONFIG } from './config';
+import * as i0 from "@angular/core";
+let loadedMonaco = false;
+let loadPromise;
+export class BaseEditor {
+    _editorContainer;
+    onInit = new EventEmitter();
+    _editor;
+    _options;
+    _windowResizeSubscription;
+    config = inject(NGX_MONACO_EDITOR_CONFIG);
+    ngAfterViewInit() {
+        if (loadedMonaco) {
+            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;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: BaseEditor, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.7", 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: "18.2.7", ngImport: i0, type: BaseEditor, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], propDecorators: { _editorContainer: [{
+                type: ViewChild,
+                args: ['editorContainer', { static: true }]
+            }], onInit: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/modules/ngx-monaco-editor/config.mjs

@@ -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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9tb2R1bGVzL25neC1tb25hY28tZWRpdG9yL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFHLElBQUksY0FBYyxDQUF3QiwwQkFBMEIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGNvbnN0IE5HWF9NT05BQ09fRURJVE9SX0NPTkZJRyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxOZ3hNb25hY29FZGl0b3JDb25maWc+KCdOR1hfTU9OQUNPX0VESVRPUl9DT05GSUcnKTtcblxuZXhwb3J0IGludGVyZmFjZSBOZ3hNb25hY29FZGl0b3JDb25maWcge1xuICBiYXNlVXJsPzogc3RyaW5nO1xuICBkZWZhdWx0T3B0aW9ucz86IHsgW2tleTogc3RyaW5nXTogYW55OyB9O1xuICBvbk1vbmFjb0xvYWQ/OiBGdW5jdGlvbjtcbn1cbiJdfQ==

package/esm2022/app/modules/ngx-monaco-editor/diff-editor.component.mjs

@@ -0,0 +1,71 @@
+import { Component, Input } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { BaseEditor } from './base-editor';
+import * as i0 from "@angular/core";
+export class DiffEditorComponent extends BaseEditor {
+    _originalModel;
+    _modifiedModel;
+    set options(options) {
+        this._options = { ...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;
+        const originalModel = monaco.editor.createModel(this._originalModel.code, this._originalModel.language);
+        const 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);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: DiffEditorComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.7", type: DiffEditorComponent, isStandalone: true, 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: [":host{display:block;height:200px}.editor-container{width:100%;height:100%}\n"] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: DiffEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-monaco-diff-editor', template: '<div class="editor-container" #editorContainer></div>', standalone: true, styles: [":host{display:block;height:200px}.editor-container{width:100%;height:100%}\n"] }]
+        }], 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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