@ng-util/monaco-editor 12.1.1 → 13.1.0

package/README.md

@@ -216,6 +216,7 @@ export class DemoComponent {
 |----------|-------------|------|---------|
 | `[height]` | Height of monaco editor | `string` | `200px` |
 | `[disabled]` | Disabled of monaco editor | `boolean` | `false` |
+| `[autoFormat]` | Whether to automatically format the document | `boolean` | `true` |
 | `[options]` | Default options when creating editors | `monaco.editor.IStandaloneEditorConstructionOptions` | - |
 | `[model]` | Model of monaco editor | `NuMonacoEditorModel` | - |
 | `[delay]` | Delay init monaco editor, unit: ms | `number` | `0` |

package/esm2020/monaco-editor-base.component.mjs

@@ -0,0 +1,152 @@
+import { DOCUMENT } from '@angular/common';
+import { Component, ElementRef, EventEmitter, Inject, Input, NgZone, Output, } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import { NU_MONACO_EDITOR_CONFIG } from './monaco-editor.config';
+import * as i0 from "@angular/core";
+let loadedMonaco = false;
+let loadPromise;
+// eslint-disable-next-line @angular-eslint/component-class-suffix
+export class NuMonacoEditorBase {
+    constructor(el, config, doc, ngZone) {
+        this.el = el;
+        this.doc = doc;
+        this.ngZone = ngZone;
+        this._resize$ = null;
+        this.height = `200px`;
+        this.delay = 0;
+        this.event = new EventEmitter();
+        this._config = { baseUrl: 'https://cdn.jsdelivr.net/npm/monaco-editor/min', ...config };
+        this.options = this._config.defaultOptions;
+    }
+    set disabled(val) {
+        this._disabled = typeof val === 'string' ? true : val;
+        this.setDisabled();
+    }
+    set options(val) {
+        this._options = { ...this._config.defaultOptions, ...val };
+    }
+    get options() {
+        return this._options;
+    }
+    notifyEvent(type, other) {
+        this.ngZone.run(() => this.event.emit({ type, editor: this._editor, ...other }));
+    }
+    setDisabled() {
+        if (this._editor) {
+            this._editor.updateOptions({ readOnly: this._disabled });
+        }
+        return this;
+    }
+    init() {
+        if (loadedMonaco) {
+            loadPromise.then(() => this.initMonaco(this.options, true));
+            return;
+        }
+        loadedMonaco = true;
+        loadPromise = new Promise((resolve, reject) => {
+            const win = window;
+            if (win == null) {
+                resolve();
+                return;
+            }
+            if (win.monaco) {
+                resolve();
+                return;
+            }
+            const baseUrl = this._config.baseUrl;
+            const amdLoader = () => {
+                win.require.config({ paths: { vs: `${baseUrl}/vs` } });
+                if (typeof this._config.monacoPreLoad === 'function') {
+                    this._config.monacoPreLoad();
+                }
+                win.require(['vs/editor/editor.main'], () => {
+                    if (typeof this._config.monacoLoad === 'function') {
+                        this._config.monacoLoad(win.monaco);
+                    }
+                    this.initMonaco(this.options, true);
+                    resolve();
+                }, () => {
+                    reject(`Unable to load editor/editor.main module, please check your network environment.`);
+                });
+            };
+            if (!win.require) {
+                const loaderScript = this.doc.createElement('script');
+                loaderScript.type = 'text/javascript';
+                loaderScript.src = `${baseUrl}/vs/loader.js`;
+                loaderScript.onload = amdLoader;
+                loaderScript.onerror = () => reject(`Unable to load ${loaderScript.src}, please check your network environment.`);
+                this.doc.getElementsByTagName('head')[0].appendChild(loaderScript);
+            }
+            else {
+                amdLoader();
+            }
+        }).catch(error => this.notifyEvent('load-error', { error }));
+    }
+    cleanResize() {
+        if (this._resize$) {
+            this._resize$.unsubscribe();
+        }
+        return this;
+    }
+    registerResize() {
+        this.cleanResize();
+        this._resize$ = fromEvent(window, 'resize')
+            .pipe(debounceTime(100))
+            .subscribe(() => {
+            this._editor.layout();
+            this.notifyEvent('resize');
+        });
+        return this;
+    }
+    updateOptions() {
+        if (!this._editor)
+            return;
+        this.ngZone.runOutsideAngular(() => {
+            this._editor.dispose();
+            this.initMonaco(this._options, false);
+        });
+    }
+    ngAfterViewInit() {
+        this.ngZone.runOutsideAngular(() => setTimeout(() => this.init(), +this.delay));
+    }
+    ngOnChanges(changes) {
+        const allKeys = Object.keys(changes);
+        if (allKeys.length === 1 && allKeys[0] === 'disabled')
+            return;
+        this.updateOptions();
+    }
+    ngOnDestroy() {
+        this.cleanResize();
+        if (this._editor) {
+            this._editor.dispose();
+            this._editor = undefined;
+        }
+    }
+}
+/** @nocollapse */ NuMonacoEditorBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NuMonacoEditorBase, deps: [{ token: i0.ElementRef }, { token: NU_MONACO_EDITOR_CONFIG }, { token: DOCUMENT }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ NuMonacoEditorBase.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: NuMonacoEditorBase, selector: "nu-monaco-base", inputs: { height: "height", delay: "delay", disabled: "disabled", options: "options" }, outputs: { event: "event" }, usesOnChanges: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NuMonacoEditorBase, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'nu-monaco-base',
+                    template: ``,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NU_MONACO_EDITOR_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.NgZone }]; }, propDecorators: { height: [{
+                type: Input
+            }], delay: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], event: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monaco-editor-base.component.js","sourceRoot":"","sources":["../../../../packages/monaco-editor/monaco-editor-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChange,\n  SimpleChanges,\n} from '@angular/core';\nimport { fromEvent, Subscription } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\nimport { NuMonacoEditorConfig, NU_MONACO_EDITOR_CONFIG } from './monaco-editor.config';\nimport { NuMonacoEditorEvent, NuMonacoEditorEventType } from './monaco-editor.types';\n\nlet loadedMonaco = false;\nlet loadPromise: Promise<void>;\n\n@Component({\n  selector: 'nu-monaco-base',\n  template: ``,\n})\n// eslint-disable-next-line @angular-eslint/component-class-suffix\nexport abstract class NuMonacoEditorBase implements AfterViewInit, OnChanges, OnDestroy {\n  protected _editor?: monaco.editor.IStandaloneCodeEditor | monaco.editor.IStandaloneDiffEditor;\n  protected _options!: monaco.editor.IStandaloneEditorConstructionOptions;\n  protected _resize$: Subscription | null = null;\n  protected _config: NuMonacoEditorConfig;\n  protected _disabled?: boolean;\n\n  @Input() height = `200px`;\n  @Input() delay = 0;\n  @Input()\n  set disabled(val: boolean | string) {\n    this._disabled = typeof val === 'string' ? true : val;\n    this.setDisabled();\n  }\n  @Input()\n  set options(val: monaco.editor.IStandaloneEditorConstructionOptions) {\n    this._options = { ...this._config.defaultOptions, ...val };\n  }\n  get options() {\n    return this._options;\n  }\n  @Output() event = new EventEmitter<NuMonacoEditorEvent>();\n\n  constructor(\n    protected el: ElementRef<HTMLElement>,\n    @Inject(NU_MONACO_EDITOR_CONFIG) config: NuMonacoEditorConfig,\n    @Inject(DOCUMENT) protected doc: any,\n    protected ngZone: NgZone,\n  ) {\n    this._config = { baseUrl: 'https://cdn.jsdelivr.net/npm/monaco-editor/min', ...config };\n    this.options = this._config.defaultOptions!;\n  }\n\n  protected abstract initMonaco(_options: monaco.editor.IStandaloneEditorConstructionOptions, _initEvent: boolean): void;\n\n  protected notifyEvent(type: NuMonacoEditorEventType, other?: NuMonacoEditorEvent): void {\n    this.ngZone.run(() => this.event.emit({ type, editor: this._editor!, ...other }));\n  }\n\n  protected setDisabled(): this {\n    if (this._editor) {\n      (this._editor as monaco.editor.IStandaloneCodeEditor).updateOptions({ readOnly: this._disabled });\n    }\n    return this;\n  }\n\n  private init(): void {\n    if (loadedMonaco) {\n      loadPromise.then(() => this.initMonaco(this.options, true));\n      return;\n    }\n\n    loadedMonaco = true;\n    loadPromise = new Promise<void>((resolve: () => void, reject: (err: string) => void) => {\n      const win: any = window;\n      if (win == null) {\n        resolve();\n        return;\n      }\n\n      if (win.monaco) {\n        resolve();\n        return;\n      }\n\n      const baseUrl = this._config.baseUrl;\n      const amdLoader = () => {\n        win.require.config({ paths: { vs: `${baseUrl}/vs` } });\n        if (typeof this._config.monacoPreLoad === 'function') {\n          this._config.monacoPreLoad();\n        }\n        win.require(\n          ['vs/editor/editor.main'],\n          () => {\n            if (typeof this._config.monacoLoad === 'function') {\n              this._config.monacoLoad(win.monaco);\n            }\n            this.initMonaco(this.options, true);\n            resolve();\n          },\n          () => {\n            reject(`Unable to load editor/editor.main module, please check your network environment.`);\n          },\n        );\n      };\n\n      if (!win.require) {\n        const loaderScript = this.doc.createElement('script') as HTMLScriptElement;\n        loaderScript.type = 'text/javascript';\n        loaderScript.src = `${baseUrl}/vs/loader.js`;\n        loaderScript.onload = amdLoader;\n        loaderScript.onerror = () => reject(`Unable to load ${loaderScript.src}, please check your network environment.`);\n        this.doc.getElementsByTagName('head')[0].appendChild(loaderScript);\n      } else {\n        amdLoader();\n      }\n    }).catch(error => this.notifyEvent('load-error', { error }));\n  }\n\n  protected cleanResize(): this {\n    if (this._resize$) {\n      this._resize$.unsubscribe();\n    }\n    return this;\n  }\n\n  protected registerResize(): this {\n    this.cleanResize();\n    this._resize$ = fromEvent(window, 'resize')\n      .pipe(debounceTime(100))\n      .subscribe(() => {\n        this._editor!.layout();\n        this.notifyEvent('resize');\n      });\n    return this;\n  }\n\n  protected updateOptions(): void {\n    if (!this._editor) return;\n    this.ngZone.runOutsideAngular(() => {\n      this._editor!.dispose();\n      this.initMonaco(this._options, false);\n    });\n  }\n\n  ngAfterViewInit(): void {\n    this.ngZone.runOutsideAngular(() => setTimeout(() => this.init(), +this.delay));\n  }\n\n  ngOnChanges(changes: { [P in keyof this]?: SimpleChange } & SimpleChanges): void {\n    const allKeys = Object.keys(changes);\n    if (allKeys.length === 1 && allKeys[0] === 'disabled') return;\n    this.updateOptions();\n  }\n\n  ngOnDestroy(): void {\n    this.cleanResize();\n    if (this._editor) {\n      this._editor.dispose();\n      this._editor = undefined;\n    }\n  }\n}\n"]}

package/esm2020/monaco-editor-diff.component.mjs

@@ -0,0 +1,47 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { NuMonacoEditorBase } from './monaco-editor-base.component';
+import * as i0 from "@angular/core";
+export class NuMonacoEditorDiffComponent extends NuMonacoEditorBase {
+    get editor() {
+        return this._editor;
+    }
+    initMonaco(options, initEvent) {
+        if (!this.old || !this.new) {
+            throw new Error('old or new not found for nu-monaco-diff-editor');
+        }
+        const theme = options.theme;
+        if (this._disabled != null)
+            options.readOnly = this._disabled;
+        const editor = (this._editor = monaco.editor.createDiffEditor(this.el.nativeElement, options));
+        options.theme = theme;
+        editor.setModel({
+            original: monaco.editor.createModel(this.old.code, this.old.language || options.language),
+            modified: monaco.editor.createModel(this.new.code, this.new.language || options.language),
+        });
+        // this.setDisabled();
+        editor.onDidUpdateDiff(() => this.notifyEvent('update-diff', { diffValue: editor.getModifiedEditor().getValue() }));
+        this.registerResize();
+        if (initEvent)
+            this.notifyEvent('init');
+    }
+}
+/** @nocollapse */ NuMonacoEditorDiffComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NuMonacoEditorDiffComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ NuMonacoEditorDiffComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: NuMonacoEditorDiffComponent, selector: "nu-monaco-diff-editor", inputs: { old: "old", new: "new" }, host: { properties: { "style.display": "'block'", "style.height": "height" } }, exportAs: ["nuMonacoDiffEditor"], usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NuMonacoEditorDiffComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'nu-monaco-diff-editor',
+                    template: ``,
+                    exportAs: 'nuMonacoDiffEditor',
+                    host: {
+                        '[style.display]': `'block'`,
+                        '[style.height]': 'height',
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { old: [{
+                type: Input
+            }], new: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/monaco-editor.component.mjs

@@ -0,0 +1,102 @@
+import { ChangeDetectionStrategy, Component, forwardRef, Input } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { NuMonacoEditorBase } from './monaco-editor-base.component';
+import * as i0 from "@angular/core";
+export class NuMonacoEditorComponent extends NuMonacoEditorBase {
+    constructor() {
+        super(...arguments);
+        this._value = '';
+        this.autoFormat = true;
+        this.onChange = (_) => { };
+        this.onTouched = () => { };
+    }
+    get editor() {
+        return this._editor;
+    }
+    initMonaco(options, initEvent) {
+        const hasModel = !!this.model;
+        if (hasModel) {
+            const model = monaco.editor.getModel(this.model.uri || '');
+            if (model) {
+                options.model = model;
+                options.model.setValue(this._value);
+            }
+            else {
+                const { value, language, uri } = this.model;
+                options.model = monaco.editor.createModel(value || this._value, language, uri);
+            }
+        }
+        if (this._disabled != null)
+            options.readOnly = this._disabled;
+        const editor = (this._editor = monaco.editor.create(this.el.nativeElement, options));
+        if (!hasModel) {
+            editor.setValue(this._value);
+        }
+        editor.onDidChangeModelContent(() => {
+            const value = editor.getValue();
+            this.ngZone.run(() => {
+                this._value = value;
+                this.onChange(value);
+            });
+        });
+        editor.onDidBlurEditorWidget(() => this.onTouched());
+        this.registerResize();
+        if (this.autoFormat) {
+            editor
+                .getAction('editor.action.formatDocument')
+                .run()
+                .then(() => this.notifyEvent(initEvent ? 'init' : 're-init'));
+            return;
+        }
+        this.notifyEvent(initEvent ? 'init' : 're-init');
+    }
+    writeValue(value) {
+        this._value = value || '';
+        if (this._editor) {
+            this._editor.setValue(this._value);
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(_isDisabled) {
+        this.disabled = _isDisabled;
+        this.setDisabled();
+    }
+}
+/** @nocollapse */ NuMonacoEditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NuMonacoEditorComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ NuMonacoEditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: NuMonacoEditorComponent, selector: "nu-monaco-editor", inputs: { model: "model", autoFormat: "autoFormat" }, host: { properties: { "style.display": "'block'", "style.height": "height" } }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef((() => NuMonacoEditorComponent)),
+            multi: true,
+        },
+    ], exportAs: ["nuMonacoEditor"], usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NuMonacoEditorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'nu-monaco-editor',
+                    template: ``,
+                    exportAs: 'nuMonacoEditor',
+                    host: {
+                        '[style.display]': `'block'`,
+                        '[style.height]': 'height',
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef((() => NuMonacoEditorComponent)),
+                            multi: true,
+                        },
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { model: [{
+                type: Input
+            }], autoFormat: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9uYWNvLWVkaXRvci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9tb25hY28tZWRpdG9yL21vbmFjby1lZGl0b3IuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN0RixPQUFPLEVBQXdCLGlCQUFpQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDekUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7O0FBb0JwRSxNQUFNLE9BQU8sdUJBQXdCLFNBQVEsa0JBQWtCO0lBakIvRDs7UUFrQlUsV0FBTSxHQUFHLEVBQUUsQ0FBQztRQUdYLGVBQVUsR0FBRyxJQUFJLENBQUM7UUFNbkIsYUFBUSxHQUFHLENBQUMsQ0FBUyxFQUFFLEVBQUUsR0FBRSxDQUFDLENBQUM7UUFDN0IsY0FBUyxHQUFHLEdBQUcsRUFBRSxHQUFFLENBQUMsQ0FBQztLQWdFOUI7SUFyRUMsSUFBSSxNQUFNO1FBQ1IsT0FBTyxJQUFJLENBQUMsT0FBOEMsQ0FBQztJQUM3RCxDQUFDO0lBS0QsVUFBVSxDQUFDLE9BQTJELEVBQUUsU0FBa0I7UUFDeEYsTUFBTSxRQUFRLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUM7UUFFOUIsSUFBSSxRQUFRLEVBQUU7WUFDWixNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsS0FBTSxDQUFDLEdBQUksSUFBSSxFQUFFLENBQUMsQ0FBQztZQUM3RCxJQUFJLEtBQUssRUFBRTtnQkFDVCxPQUFPLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztnQkFDdEIsT0FBTyxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO2FBQ3JDO2lCQUFNO2dCQUNMLE1BQU0sRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLEdBQUcsRUFBRSxHQUFHLElBQUksQ0FBQyxLQUFNLENBQUM7Z0JBQzdDLE9BQU8sQ0FBQyxLQUFLLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsS0FBSyxJQUFJLElBQUksQ0FBQyxNQUFNLEVBQUUsUUFBUSxFQUFFLEdBQUcsQ0FBQyxDQUFDO2FBQ2hGO1NBQ0Y7UUFFRCxJQUFJLElBQUksQ0FBQyxTQUFTLElBQUksSUFBSTtZQUFFLE9BQU8sQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQztRQUM5RCxNQUFNLE1BQU0sR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxhQUFhLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUVyRixJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ2IsTUFBTSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7U0FDOUI7UUFFRCxNQUFNLENBQUMsdUJBQXVCLENBQUMsR0FBRyxFQUFFO1lBQ2xDLE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUVoQyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUU7Z0JBQ25CLElBQUksQ0FBQyxNQUFNLEdBQUcsS0FBSyxDQUFDO2dCQUNwQixJQUFJLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ3ZCLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQyxDQUFDLENBQUM7UUFDSCxNQUFNLENBQUMscUJBQXFCLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUM7UUFFckQsSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBRXRCLElBQUksSUFBSSxDQUFDLFVBQVUsRUFBRTtZQUNuQixNQUFNO2lCQUNILFNBQVMsQ0FBQyw4QkFBOEIsQ0FBQztpQkFDekMsR0FBRyxFQUFFO2lCQUNMLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDO1lBQ2hFLE9BQU87U0FDUjtRQUNELElBQUksQ0FBQyxXQUFXLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ25ELENBQUM7SUFFRCxVQUFVLENBQUMsS0FBYTtRQUN0QixJQUFJLENBQUMsTUFBTSxHQUFHLEtBQUssSUFBSSxFQUFFLENBQUM7UUFDMUIsSUFBSSxJQUFJLENBQUMsT0FBTyxFQUFFO1lBQ2YsSUFBSSxDQUFDLE9BQStDLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztTQUM3RTtJQUNILENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxFQUF1QjtRQUN0QyxJQUFJLENBQUMsUUFBUSxHQUFHLEVBQUUsQ0FBQztJQUNyQixDQUFDO0lBRUQsaUJBQWlCLENBQUMsRUFBTztRQUN2QixJQUFJLENBQUMsU0FBUyxHQUFHLEVBQUUsQ0FBQztJQUN0QixDQUFDO0lBRUQsZ0JBQWdCLENBQUMsV0FBb0I7UUFDbkMsSUFBSSxDQUFDLFFBQVEsR0FBRyxXQUFXLENBQUM7UUFDNUIsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQ3JCLENBQUM7O3dJQTFFVSx1QkFBdUI7NEhBQXZCLHVCQUF1QixpTEFUdkI7UUFDVDtZQUNFLE9BQU8sRUFBRSxpQkFBaUI7WUFDMUIsV0FBVyxFQUFFLFVBQVUsRUFBQyxHQUFHLEVBQUUsQ0FBQyx1QkFBdUIsRUFBQztZQUN0RCxLQUFLLEVBQUUsSUFBSTtTQUNaO0tBQ0YsK0VBWlMsRUFBRTs0RkFlRCx1QkFBdUI7a0JBakJuQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxrQkFBa0I7b0JBQzVCLFFBQVEsRUFBRSxFQUFFO29CQUNaLFFBQVEsRUFBRSxnQkFBZ0I7b0JBQzFCLElBQUksRUFBRTt3QkFDSixpQkFBaUIsRUFBRSxTQUFTO3dCQUM1QixnQkFBZ0IsRUFBRSxRQUFRO3FCQUMzQjtvQkFDRCxTQUFTLEVBQUU7d0JBQ1Q7NEJBQ0UsT0FBTyxFQUFFLGlCQUFpQjs0QkFDMUIsV0FBVyxFQUFFLFVBQVUsRUFBQyxHQUFHLEVBQUUsd0JBQXdCLEVBQUM7NEJBQ3RELEtBQUssRUFBRSxJQUFJO3lCQUNaO3FCQUNGO29CQUNELGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO2lCQUNoRDs4QkFJVSxLQUFLO3NCQUFiLEtBQUs7Z0JBQ0csVUFBVTtzQkFBbEIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIGZvcndhcmRSZWYsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb250cm9sVmFsdWVBY2Nlc3NvciwgTkdfVkFMVUVfQUNDRVNTT1IgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBOdU1vbmFjb0VkaXRvckJhc2UgfSBmcm9tICcuL21vbmFjby1lZGl0b3ItYmFzZS5jb21wb25lbnQnO1xuaW1wb3J0IHsgTnVNb25hY29FZGl0b3JNb2RlbCB9IGZyb20gJy4vbW9uYWNvLWVkaXRvci50eXBlcyc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ251LW1vbmFjby1lZGl0b3InLFxuICB0ZW1wbGF0ZTogYGAsXG4gIGV4cG9ydEFzOiAnbnVNb25hY29FZGl0b3InLFxuICBob3N0OiB7XG4gICAgJ1tzdHlsZS5kaXNwbGF5XSc6IGAnYmxvY2snYCxcbiAgICAnW3N0eWxlLmhlaWdodF0nOiAnaGVpZ2h0JyxcbiAgfSxcbiAgcHJvdmlkZXJzOiBbXG4gICAge1xuICAgICAgcHJvdmlkZTogTkdfVkFMVUVfQUNDRVNTT1IsXG4gICAgICB1c2VFeGlzdGluZzogZm9yd2FyZFJlZigoKSA9PiBOdU1vbmFjb0VkaXRvckNvbXBvbmVudCksXG4gICAgICBtdWx0aTogdHJ1ZSxcbiAgICB9LFxuICBdLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbn0pXG5leHBvcnQgY2xhc3MgTnVNb25hY29FZGl0b3JDb21wb25lbnQgZXh0ZW5kcyBOdU1vbmFjb0VkaXRvckJhc2UgaW1wbGVtZW50cyBDb250cm9sVmFsdWVBY2Nlc3NvciB7XG4gIHByaXZhdGUgX3ZhbHVlID0gJyc7XG5cbiAgQElucHV0KCkgbW9kZWw/OiBOdU1vbmFjb0VkaXRvck1vZGVsIHwgbnVsbDtcbiAgQElucHV0KCkgYXV0b0Zvcm1hdCA9IHRydWU7XG5cbiAgZ2V0IGVkaXRvcigpOiBtb25hY28uZWRpdG9yLklTdGFuZGFsb25lQ29kZUVkaXRvciB7XG4gICAgcmV0dXJuIHRoaXMuX2VkaXRvciBhcyBtb25hY28uZWRpdG9yLklTdGFuZGFsb25lQ29kZUVkaXRvcjtcbiAgfVxuXG4gIHByaXZhdGUgb25DaGFuZ2UgPSAoXzogc3RyaW5nKSA9PiB7fTtcbiAgcHJpdmF0ZSBvblRvdWNoZWQgPSAoKSA9PiB7fTtcblxuICBpbml0TW9uYWNvKG9wdGlvbnM6IG1vbmFjby5lZGl0b3IuSVN0YW5kYWxvbmVFZGl0b3JDb25zdHJ1Y3Rpb25PcHRpb25zLCBpbml0RXZlbnQ6IGJvb2xlYW4pOiB2b2lkIHtcbiAgICBjb25zdCBoYXNNb2RlbCA9ICEhdGhpcy5tb2RlbDtcblxuICAgIGlmIChoYXNNb2RlbCkge1xuICAgICAgY29uc3QgbW9kZWwgPSBtb25hY28uZWRpdG9yLmdldE1vZGVsKHRoaXMubW9kZWwhLnVyaSEgfHwgJycpO1xuICAgICAgaWYgKG1vZGVsKSB7XG4gICAgICAgIG9wdGlvbnMubW9kZWwgPSBtb2RlbDtcbiAgICAgICAgb3B0aW9ucy5tb2RlbC5zZXRWYWx1ZSh0aGlzLl92YWx1ZSk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICBjb25zdCB7IHZhbHVlLCBsYW5ndWFnZSwgdXJpIH0gPSB0aGlzLm1vZGVsITtcbiAgICAgICAgb3B0aW9ucy5tb2RlbCA9IG1vbmFjby5lZGl0b3IuY3JlYXRlTW9kZWwodmFsdWUgfHwgdGhpcy5fdmFsdWUsIGxhbmd1YWdlLCB1cmkpO1xuICAgICAgfVxuICAgIH1cblxuICAgIGlmICh0aGlzLl9kaXNhYmxlZCAhPSBudWxsKSBvcHRpb25zLnJlYWRPbmx5ID0gdGhpcy5fZGlzYWJsZWQ7XG4gICAgY29uc3QgZWRpdG9yID0gKHRoaXMuX2VkaXRvciA9IG1vbmFjby5lZGl0b3IuY3JlYXRlKHRoaXMuZWwubmF0aXZlRWxlbWVudCwgb3B0aW9ucykpO1xuXG4gICAgaWYgKCFoYXNNb2RlbCkge1xuICAgICAgZWRpdG9yLnNldFZhbHVlKHRoaXMuX3ZhbHVlKTtcbiAgICB9XG5cbiAgICBlZGl0b3Iub25EaWRDaGFuZ2VNb2RlbENvbnRlbnQoKCkgPT4ge1xuICAgICAgY29uc3QgdmFsdWUgPSBlZGl0b3IuZ2V0VmFsdWUoKTtcblxuICAgICAgdGhpcy5uZ1pvbmUucnVuKCgpID0+IHtcbiAgICAgICAgdGhpcy5fdmFsdWUgPSB2YWx1ZTtcbiAgICAgICAgdGhpcy5vbkNoYW5nZSh2YWx1ZSk7XG4gICAgICB9KTtcbiAgICB9KTtcbiAgICBlZGl0b3Iub25EaWRCbHVyRWRpdG9yV2lkZ2V0KCgpID0+IHRoaXMub25Ub3VjaGVkKCkpO1xuXG4gICAgdGhpcy5yZWdpc3RlclJlc2l6ZSgpO1xuXG4gICAgaWYgKHRoaXMuYXV0b0Zvcm1hdCkge1xuICAgICAgZWRpdG9yXG4gICAgICAgIC5nZXRBY3Rpb24oJ2VkaXRvci5hY3Rpb24uZm9ybWF0RG9jdW1lbnQnKVxuICAgICAgICAucnVuKClcbiAgICAgICAgLnRoZW4oKCkgPT4gdGhpcy5ub3RpZnlFdmVudChpbml0RXZlbnQgPyAnaW5pdCcgOiAncmUtaW5pdCcpKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG4gICAgdGhpcy5ub3RpZnlFdmVudChpbml0RXZlbnQgPyAnaW5pdCcgOiAncmUtaW5pdCcpO1xuICB9XG5cbiAgd3JpdGVWYWx1ZSh2YWx1ZTogc3RyaW5nKTogdm9pZCB7XG4gICAgdGhpcy5fdmFsdWUgPSB2YWx1ZSB8fCAnJztcbiAgICBpZiAodGhpcy5fZWRpdG9yKSB7XG4gICAgICAodGhpcy5fZWRpdG9yIGFzIG1vbmFjby5lZGl0b3IuSVN0YW5kYWxvbmVDb2RlRWRpdG9yKS5zZXRWYWx1ZSh0aGlzLl92YWx1ZSk7XG4gICAgfVxuICB9XG5cbiAgcmVnaXN0ZXJPbkNoYW5nZShmbjogKF86IHN0cmluZykgPT4gdm9pZCk6IHZvaWQge1xuICAgIHRoaXMub25DaGFuZ2UgPSBmbjtcbiAgfVxuXG4gIHJlZ2lzdGVyT25Ub3VjaGVkKGZuOiBhbnkpOiB2b2lkIHtcbiAgICB0aGlzLm9uVG91Y2hlZCA9IGZuO1xuICB9XG5cbiAgc2V0RGlzYWJsZWRTdGF0ZShfaXNEaXNhYmxlZDogYm9vbGVhbik6IHZvaWQge1xuICAgIHRoaXMuZGlzYWJsZWQgPSBfaXNEaXNhYmxlZDtcbiAgICB0aGlzLnNldERpc2FibGVkKCk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/monaco-editor.config.mjs

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

package/esm2020/monaco-editor.module.mjs

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

package/esm2020/ng-util-monaco-editor.mjs

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