@gravitee/ui-particles-angular 15.13.0-angular-20-f024970 → 15.13.0-test-npm-publish-aaef706

package/esm2022/lib/gio-monaco-editor/gio-monaco-editor.component.mjs

@@ -0,0 +1,314 @@
+/*
+ * Copyright (C) 2023 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ChangeDetectionStrategy, Component, effect, HostBinding, Inject, Input, Optional, Self, signal, } from '@angular/core';
+import { isEqual, isString, uniqueId } from 'lodash';
+import { ReplaySubject, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { GIO_MONACO_EDITOR_CONFIG } from './models/GioMonacoEditorConfig';
+import * as i0 from "@angular/core";
+import * as i1 from "./services/gio-monaco-editor.service";
+import * as i2 from "./services/gio-language-json.service";
+import * as i3 from "./services/gio-language-el.service";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/common";
+export class GioMonacoEditorComponent {
+    constructor(hostElement, config, monacoEditorService, languageJsonService, languageSpelService, changeDetectorRef, ngZone, ngControl) {
+        this.hostElement = hostElement;
+        this.config = config;
+        this.monacoEditorService = monacoEditorService;
+        this.languageJsonService = languageJsonService;
+        this.languageSpelService = languageSpelService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.ngZone = ngZone;
+        this.ngControl = ngControl;
+        this.options = {};
+        this.disableMiniMap = false;
+        this.disableAutoFormat = false;
+        this.singleLineMode = false;
+        this.loaded$ = new ReplaySubject(1);
+        this.defaultOptions = {
+            contextmenu: false,
+            minimap: {
+                enabled: true,
+            },
+            automaticLayout: true,
+            scrollBeyondLastLine: false,
+        };
+        this.value = '';
+        this.readOnly = false;
+        this.toDisposes = [];
+        this.isMonacoEditorReady = signal({
+            isSetup: false,
+            hasFirstValue: false,
+        });
+        this._onChange = () => ({});
+        this._onTouched = () => ({});
+        this.unsubscribe$ = new Subject();
+        if (this.ngControl) {
+            // Set the value accessor directly (instead of providing
+            // NG_VALUE_ACCESSOR) to avoid running into a circular import
+            this.ngControl.valueAccessor = this;
+        }
+        this.monacoEditorService.loadEditor();
+        effect(() => {
+            const { isSetup, hasFirstValue } = this.isMonacoEditorReady();
+            if (isSetup && hasFirstValue) {
+                if (this.textModel) {
+                    this.textModel.setValue(this.value);
+                }
+                this.updateModelLanguage();
+                this.autoformatValue();
+            }
+        });
+    }
+    ngAfterViewInit() {
+        // Wait until monaco editor is available
+        this.monacoEditorService.loaded$.pipe(takeUntil(this.unsubscribe$)).subscribe(({ monaco }) => {
+            this.setupEditor(monaco);
+            this.isMonacoEditorReady.update(({ hasFirstValue }) => ({ isSetup: true, hasFirstValue }));
+            this.loaded$.next(false);
+            this.changeDetectorRef.detectChanges();
+        });
+    }
+    ngOnDestroy() {
+        this.toDisposes.forEach(d => d.dispose());
+        if (this.standaloneCodeEditor) {
+            this.standaloneCodeEditor.dispose();
+            this.standaloneCodeEditor = undefined;
+        }
+        if (this.textModel) {
+            this.textModel.dispose();
+            this.textModel = undefined;
+        }
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+    // From ControlValueAccessor interface
+    writeValue(_value) {
+        if (_value) {
+            this.value = isString(_value) ? _value : JSON.stringify(_value);
+            this.isMonacoEditorReady.update(({ isSetup }) => ({ isSetup, hasFirstValue: true }));
+        }
+    }
+    // From ControlValueAccessor interface
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    // From ControlValueAccessor interface
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    // From ControlValueAccessor interface
+    setDisabledState(isDisabled) {
+        this.readOnly = isDisabled;
+        if (this.standaloneCodeEditor) {
+            this.standaloneCodeEditor.updateOptions({
+                readOnly: isDisabled,
+            });
+        }
+    }
+    setupEditor(monaco) {
+        if (!this.hostElement) {
+            throw new Error('No editor ref found.');
+        }
+        const domElement = this.hostElement.nativeElement;
+        const settings = {
+            value: this.value,
+            language: this.languageConfig?.language ?? (isJsonString(this.value) ? 'json' : 'plaintext'),
+            uri: `code-${uniqueId()}`,
+        };
+        this.ngZone.runOutsideAngular(() => {
+            this.textModel = monaco.editor.createModel(settings.value, settings.language, monaco.Uri.parse(settings.uri));
+        });
+        const options = Object.assign({}, this.defaultOptions, this.options, {
+            readOnly: !this.ngControl && 'readOnly' in this.options ? this.options.readOnly : this.readOnly,
+            theme: this.config.theme ?? 'vs',
+            model: this.textModel,
+            minimap: {
+                enabled: !this.disableMiniMap,
+            },
+        });
+        this.standaloneCodeEditor = monaco.editor.create(domElement, {
+            ...options,
+        });
+        if (this.singleLineMode) {
+            this.standaloneCodeEditor?.addAction({
+                id: 'custom.action',
+                label: 'custom action',
+                keybindings: [monaco.KeyCode.Enter],
+                precondition: '!suggestWidgetVisible && !renameInputVisible && !inSnippetMode && !quickFixWidgetVisible',
+                run: () => {
+                    // Ignore Enter key in single line mode when writing
+                    return;
+                },
+            });
+        }
+        const onDidChangeContent = this.textModel?.onDidChangeContent(() => {
+            const textModelValue = this.textModel?.getValue() ?? '';
+            if (this.singleLineMode) {
+                // If value has \n, \r or \r\n, remove them
+                // Useful to clear line breaks when pasting text
+                const hasLineBreak = new RegExp(/(\r\n|\n|\r)/gm);
+                if (hasLineBreak.test(textModelValue)) {
+                    const currentPosition = this.standaloneCodeEditor?.getPosition();
+                    setTimeout(() => {
+                        this.standaloneCodeEditor?.pushUndoStop();
+                        this.textModel?.setValue(textModelValue.replace(/(\r\n|\n|\r)/gm, ''));
+                        if (currentPosition) {
+                            this.standaloneCodeEditor?.setPosition(currentPosition);
+                        }
+                        this.standaloneCodeEditor?.popUndoStop();
+                    }, 0);
+                    return;
+                }
+            }
+            this.ngZone.run(() => {
+                if (!this.readOnly && !isEqual(this.value, textModelValue)) {
+                    setTimeout(() => {
+                        this.value = textModelValue;
+                        this._onChange(textModelValue);
+                        this._onTouched();
+                    }, 0);
+                }
+            });
+        });
+        if (this.singleLineMode) {
+            // Source : https://farzadyz.com/blog/single-line-monaco-editor
+            this.standaloneCodeEditor?.updateOptions({
+                // quickSuggestions: false,
+                fixedOverflowWidgets: true,
+                acceptSuggestionOnEnter: 'on',
+                hover: {
+                    delay: 100,
+                },
+                roundedSelection: false,
+                contextmenu: false,
+                cursorStyle: 'line-thin',
+                links: false,
+                find: {
+                    addExtraSpaceOnTop: false,
+                    autoFindInSelection: 'never',
+                    seedSearchStringFromSelection: 'never',
+                },
+                fontSize: 14,
+                fontWeight: 'normal',
+                overviewRulerLanes: 0,
+                scrollBeyondLastColumn: 0,
+                wordWrap: 'on',
+                minimap: {
+                    enabled: false,
+                },
+                lineNumbers: 'off',
+                hideCursorInOverviewRuler: true,
+                overviewRulerBorder: false,
+                glyphMargin: false,
+                folding: false,
+                lineDecorationsWidth: 0,
+                lineNumbersMinChars: 0,
+                renderLineHighlight: 'none',
+                scrollbar: {
+                    horizontal: 'hidden',
+                    vertical: 'hidden',
+                    alwaysConsumeMouseWheel: false,
+                },
+            });
+        }
+        const onDidBlurEditorWidget = this.standaloneCodeEditor?.onDidBlurEditorWidget(() => {
+            this.ngZone.run(() => {
+                if (!this.readOnly)
+                    this._onTouched();
+            });
+        });
+        this.toDisposes = [onDidChangeContent, onDidBlurEditorWidget].filter(d => !!d);
+        this.setupLanguage(settings.uri, this.languageConfig);
+    }
+    setupLanguage(uri, languageConfig) {
+        if (!languageConfig) {
+            return;
+        }
+        switch (languageConfig.language) {
+            case 'json':
+                if (languageConfig.schemas) {
+                    this.languageJsonService.addSchemas(uri, languageConfig.schemas);
+                }
+                break;
+            case 'spel':
+                if (languageConfig.schema) {
+                    this.languageSpelService.setSchema(languageConfig.schema);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    updateModelLanguage() {
+        const languageId = this.languageConfig?.language ?? (isJsonString(this.value) ? 'json' : 'plaintext');
+        if (this.textModel && window.monaco) {
+            window.monaco.editor.setModelLanguage(this.textModel, languageId);
+        }
+    }
+    autoformatValue() {
+        if (!this.disableAutoFormat) {
+            setTimeout(() => {
+                const previousReadOnlyState = this.options.readOnly || this.readOnly;
+                this.standaloneCodeEditor?.updateOptions({ readOnly: false });
+                this.standaloneCodeEditor
+                    ?.getAction('editor.action.formatDocument')
+                    ?.run()
+                    .finally(() => {
+                    this.standaloneCodeEditor?.updateOptions({ readOnly: previousReadOnlyState });
+                    this.changeDetectorRef.detectChanges();
+                });
+            }, 80);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioMonacoEditorComponent, deps: [{ token: i0.ElementRef }, { token: GIO_MONACO_EDITOR_CONFIG }, { token: i1.GioMonacoEditorService }, { token: i2.GioLanguageJsonService }, { token: i3.GioLanguageElService }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i4.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", type: GioMonacoEditorComponent, isStandalone: false, selector: "gio-monaco-editor", inputs: { languageConfig: "languageConfig", options: "options", disableMiniMap: "disableMiniMap", disableAutoFormat: "disableAutoFormat", singleLineMode: "singleLineMode" }, host: { properties: { "class.single-line": "this.singleLineMode" } }, ngImport: i0, template: ` <div *ngIf="loaded$ | async">Loading...</div>`, isInline: true, styles: [":host{display:block;height:100%;min-height:150px;pointer-events:auto;transition:opacity .2s ease-out}:host.single-line{display:flex;height:24px;min-height:24px;align-items:center}:host-context(.hidden){opacity:0}\n"], dependencies: [{ kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioMonacoEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'gio-monaco-editor', template: ` <div *ngIf="loaded$ | async">Loading...</div>`, changeDetection: ChangeDetectionStrategy.OnPush, standalone: false, styles: [":host{display:block;height:100%;min-height:150px;pointer-events:auto;transition:opacity .2s ease-out}:host.single-line{display:flex;height:24px;min-height:24px;align-items:center}:host-context(.hidden){opacity:0}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [GIO_MONACO_EDITOR_CONFIG]
+                }] }, { type: i1.GioMonacoEditorService }, { type: i2.GioLanguageJsonService }, { type: i3.GioLanguageElService }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i4.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }], propDecorators: { languageConfig: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], disableMiniMap: [{
+                type: Input
+            }], disableAutoFormat: [{
+                type: Input
+            }], singleLineMode: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.single-line']
+            }] } });
+const isJsonString = (str) => {
+    try {
+        JSON.parse(str);
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gio-monaco-editor.component.js","sourceRoot":"","sources":["../../../../../projects/ui-particles-angular/src/lib/gio-monaco-editor/gio-monaco-editor.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAEL,uBAAuB,EAEvB,SAAS,EACT,MAAM,EAEN,WAAW,EACX,MAAM,EACN,KAAK,EAGL,QAAQ,EACR,IAAI,EACJ,MAAM,GAEP,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,EAAE,wBAAwB,EAAyB,MAAM,gCAAgC,CAAC;;;;;;;AAmCjG,MAAM,OAAO,wBAAwB;IA4CnC,YACkB,WAAuB,EACY,MAA6B,EAC/D,mBAA2C,EAC3C,mBAA2C,EAC3C,mBAAyC,EACzC,iBAAoC,EACpC,MAAc,EACK,SAAoB;QAPxC,gBAAW,GAAX,WAAW,CAAY;QACY,WAAM,GAAN,MAAM,CAAuB;QAC/D,wBAAmB,GAAnB,mBAAmB,CAAwB;QAC3C,wBAAmB,GAAnB,mBAAmB,CAAwB;QAC3C,wBAAmB,GAAnB,mBAAmB,CAAsB;QACzC,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,WAAM,GAAN,MAAM,CAAQ;QACK,cAAS,GAAT,SAAS,CAAW;QA/CnD,YAAO,GAAgD,EAAE,CAAC;QAG1D,mBAAc,GAAG,KAAK,CAAC;QAGvB,sBAAiB,GAAG,KAAK,CAAC;QAI1B,mBAAc,GAAG,KAAK,CAAC;QAEvB,YAAO,GAAG,IAAI,aAAa,CAAU,CAAC,CAAC,CAAC;QAEvC,mBAAc,GAAgD;YACpE,WAAW,EAAE,KAAK;YAClB,OAAO,EAAE;gBACP,OAAO,EAAE,IAAI;aACd;YACD,eAAe,EAAE,IAAI;YACrB,oBAAoB,EAAE,KAAK;SAC5B,CAAC;QAEK,UAAK,GAAG,EAAE,CAAC;QACX,aAAQ,GAAG,KAAK,CAAC;QAGhB,eAAU,GAAyB,EAAE,CAAC;QAEtC,wBAAmB,GAAiE,MAAM,CAAC;YACjG,OAAO,EAAE,KAAK;YACd,aAAa,EAAE,KAAK;SACrB,CAAC,CAAC;QAEO,cAAS,GAAoC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QAExD,eAAU,GAAe,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QACtC,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;QAYzC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,wDAAwD;YACxD,6DAA6D;YAC7D,IAAI,CAAC,SAAS,CAAC,aAAa,GAAG,IAAI,CAAC;QACtC,CAAC;QACD,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,CAAC;QAEtC,MAAM,CAAC,GAAG,EAAE;YACV,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC9D,IAAI,OAAO,IAAI,aAAa,EAAE,CAAC;gBAC7B,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;oBACnB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACtC,CAAC;gBAED,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC3B,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,eAAe;QACpB,wCAAwC;QACxC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE;YAC3F,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YACzB,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,EAAE,aAAa,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC;YAE3F,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACzB,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;QACzC,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;QAE1C,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC9B,IAAI,CAAC,oBAAoB,CAAC,OAAO,EAAE,CAAC;YACpC,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC;QACxC,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;YACzB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC7B,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;QACzB,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;IAC/B,CAAC;IAED,sCAAsC;IAC/B,UAAU,CAAC,MAAqB;QACrC,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YAChE,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACvF,CAAC;IACH,CAAC;IAED,sCAAsC;IAC/B,gBAAgB,CAAC,EAAmC;QACzD,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAED,sCAAsC;IAC/B,iBAAiB,CAAC,EAAc;QACrC,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;IACvB,CAAC;IAED,sCAAsC;IAC/B,gBAAgB,CAAC,UAAmB;QACzC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;QAE3B,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC9B,IAAI,CAAC,oBAAoB,CAAC,aAAa,CAAC;gBACtC,QAAQ,EAAE,UAAU;aACrB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEO,WAAW,CAAC,MAAqB;QACvC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAC1C,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC;QAElD,MAAM,QAAQ,GAAG;YACf,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,QAAQ,EAAE,IAAI,CAAC,cAAc,EAAE,QAAQ,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC;YAC5F,GAAG,EAAE,QAAQ,QAAQ,EAAE,EAAE;SAC1B,CAAC;QAEF,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE;YACjC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;QAChH,CAAC,CAAC,CAAC;QAEH,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,OAAO,EAAE;YACnE,QAAQ,EAAE,CAAC,IAAI,CAAC,SAAS,IAAI,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ;YAC/F,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,IAAI;YAChC,KAAK,EAAE,IAAI,CAAC,SAAS;YACrB,OAAO,EAAE;gBACP,OAAO,EAAE,CAAC,IAAI,CAAC,cAAc;aAC9B;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE;YAC3D,GAAG,OAAO;SACX,CAAC,CAAC;QAEH,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC;gBACnC,EAAE,EAAE,eAAe;gBACnB,KAAK,EAAE,eAAe;gBACtB,WAAW,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC;gBACnC,YAAY,EAAE,0FAA0F;gBACxG,GAAG,EAAE,GAAG,EAAE;oBACR,oDAAoD;oBACpD,OAAO;gBACT,CAAC;aACF,CAAC,CAAC;QACL,CAAC;QAED,MAAM,kBAAkB,GAAG,IAAI,CAAC,SAAS,EAAE,kBAAkB,CAAC,GAAG,EAAE;YACjE,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;YACxD,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;gBACxB,2CAA2C;gBAC3C,gDAAgD;gBAChD,MAAM,YAAY,GAAG,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAAC;gBAClD,IAAI,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;oBACtC,MAAM,eAAe,GAAG,IAAI,CAAC,oBAAoB,EAAE,WAAW,EAAE,CAAC;oBACjE,UAAU,CAAC,GAAG,EAAE;wBACd,IAAI,CAAC,oBAAoB,EAAE,YAAY,EAAE,CAAC;wBAC1C,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC,CAAC;wBACvE,IAAI,eAAe,EAAE,CAAC;4BACpB,IAAI,CAAC,oBAAoB,EAAE,WAAW,CAAC,eAAe,CAAC,CAAC;wBAC1D,CAAC;wBACD,IAAI,CAAC,oBAAoB,EAAE,WAAW,EAAE,CAAC;oBAC3C,CAAC,EAAE,CAAC,CAAC,CAAC;oBACN,OAAO;gBACT,CAAC;YACH,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE;gBACnB,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,cAAc,CAAC,EAAE,CAAC;oBAC3D,UAAU,CAAC,GAAG,EAAE;wBACd,IAAI,CAAC,KAAK,GAAG,cAAc,CAAC;wBAC5B,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;wBAC/B,IAAI,CAAC,UAAU,EAAE,CAAC;oBACpB,CAAC,EAAE,CAAC,CAAC,CAAC;gBACR,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,+DAA+D;YAC/D,IAAI,CAAC,oBAAoB,EAAE,aAAa,CAAC;gBACvC,2BAA2B;gBAC3B,oBAAoB,EAAE,IAAI;gBAC1B,uBAAuB,EAAE,IAAI;gBAC7B,KAAK,EAAE;oBACL,KAAK,EAAE,GAAG;iBACX;gBACD,gBAAgB,EAAE,KAAK;gBACvB,WAAW,EAAE,KAAK;gBAClB,WAAW,EAAE,WAAW;gBACxB,KAAK,EAAE,KAAK;gBACZ,IAAI,EAAE;oBACJ,kBAAkB,EAAE,KAAK;oBACzB,mBAAmB,EAAE,OAAO;oBAC5B,6BAA6B,EAAE,OAAO;iBACvC;gBACD,QAAQ,EAAE,EAAE;gBACZ,UAAU,EAAE,QAAQ;gBACpB,kBAAkB,EAAE,CAAC;gBACrB,sBAAsB,EAAE,CAAC;gBACzB,QAAQ,EAAE,IAAI;gBACd,OAAO,EAAE;oBACP,OAAO,EAAE,KAAK;iBACf;gBACD,WAAW,EAAE,KAAK;gBAClB,yBAAyB,EAAE,IAAI;gBAC/B,mBAAmB,EAAE,KAAK;gBAC1B,WAAW,EAAE,KAAK;gBAClB,OAAO,EAAE,KAAK;gBACd,oBAAoB,EAAE,CAAC;gBACvB,mBAAmB,EAAE,CAAC;gBACtB,mBAAmB,EAAE,MAAM;gBAC3B,SAAS,EAAE;oBACT,UAAU,EAAE,QAAQ;oBACpB,QAAQ,EAAE,QAAQ;oBAClB,uBAAuB,EAAE,KAAK;iBAC/B;aACF,CAAC,CAAC;QACL,CAAC;QAED,MAAM,qBAAqB,GAAG,IAAI,CAAC,oBAAoB,EAAE,qBAAqB,CAAC,GAAG,EAAE;YAClF,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE;gBACnB,IAAI,CAAC,IAAI,CAAC,QAAQ;oBAAE,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,GAAG,CAAC,kBAAkB,EAAE,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAyB,CAAC;QAEvG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IACxD,CAAC;IAEO,aAAa,CAAC,GAAW,EAAE,cAA2C;QAC5E,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,OAAO;QACT,CAAC;QAED,QAAQ,cAAc,CAAC,QAAQ,EAAE,CAAC;YAChC,KAAK,MAAM;gBACT,IAAI,cAAc,CAAC,OAAO,EAAE,CAAC;oBAC3B,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,GAAG,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;gBACnE,CAAC;gBACD,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,cAAc,CAAC,MAAM,EAAE,CAAC;oBAC1B,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;gBAC5D,CAAC;gBACD,MAAM;YACR;gBACE,MAAM;QACV,CAAC;IACH,CAAC;IAEO,mBAAmB;QACzB,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,EAAE,QAAQ,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;QACtG,IAAI,IAAI,CAAC,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YACpC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAEO,eAAe;QACrB,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC5B,UAAU,CAAC,GAAG,EAAE;gBACd,MAAM,qBAAqB,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC;gBACrE,IAAI,CAAC,oBAAoB,EAAE,aAAa,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;gBAC9D,IAAI,CAAC,oBAAoB;oBACvB,EAAE,SAAS,CAAC,8BAA8B,CAAC;oBAC3C,EAAE,GAAG,EAAE;qBACN,OAAO,CAAC,GAAG,EAAE;oBACZ,IAAI,CAAC,oBAAoB,EAAE,aAAa,CAAC,EAAE,QAAQ,EAAE,qBAAqB,EAAE,CAAC,CAAC;oBAC9E,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;gBACzC,CAAC,CAAC,CAAC;YACP,CAAC,EAAE,EAAE,CAAC,CAAC;QACT,CAAC;IACH,CAAC;8GA3SU,wBAAwB,4CA8CzB,wBAAwB;kGA9CvB,wBAAwB,kUALzB,gDAAgD;;2FAK/C,wBAAwB;kBAPpC,SAAS;+BACE,mBAAmB,YACnB,gDAAgD,mBAEzC,uBAAuB,CAAC,MAAM,cACnC,KAAK;;0BAgDd,MAAM;2BAAC,wBAAwB;;0BAM/B,QAAQ;;0BAAI,IAAI;yCAlDZ,cAAc;sBADpB,KAAK;gBAIC,OAAO;sBADb,KAAK;gBAIC,cAAc;sBADpB,KAAK;gBAIC,iBAAiB;sBADvB,KAAK;gBAKC,cAAc;sBAFpB,KAAK;;sBACL,WAAW;uBAAC,mBAAmB;;AAgSlC,MAAM,YAAY,GAAG,CAAC,GAAW,EAAW,EAAE;IAC5C,IAAI,CAAC;QACH,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAClB,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CAAC","sourcesContent":["/*\n * Copyright (C) 2023 The Gravitee team (http://gravitee.io)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  effect,\n  ElementRef,\n  HostBinding,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Self,\n  signal,\n  WritableSignal,\n} from '@angular/core';\nimport { ControlValueAccessor, NgControl } from '@angular/forms';\nimport { isEqual, isString, uniqueId } from 'lodash';\nimport Monaco, { editor } from 'monaco-editor';\nimport { ReplaySubject, Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { GIO_MONACO_EDITOR_CONFIG, GioMonacoEditorConfig } from './models/GioMonacoEditorConfig';\nimport { GioLanguageJsonService } from './services/gio-language-json.service';\nimport { GioMonacoEditorService } from './services/gio-monaco-editor.service';\nimport { GioLanguageElService } from './services/gio-language-el.service';\nimport { JSONSchema } from './models/JSONSchemaAutoComplete';\n\nexport type MonacoEditorLanguageConfig =\n  | {\n      language: 'json';\n      schemas?: { uri: string; schema: unknown }[];\n    }\n  | {\n      language: 'markdown';\n    }\n  | {\n      language: 'html';\n    }\n  | {\n      language: 'yaml';\n    }\n  | {\n      language: 'spel';\n      schema?: JSONSchema;\n    }\n  | {\n      language: 'css';\n    };\n\n@Component({\n  selector: 'gio-monaco-editor',\n  template: ` <div *ngIf=\"loaded$ | async\">Loading...</div>`,\n  styleUrls: ['./gio-monaco-editor.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: false,\n})\nexport class GioMonacoEditorComponent implements ControlValueAccessor, AfterViewInit, OnDestroy {\n  @Input()\n  public languageConfig?: MonacoEditorLanguageConfig;\n\n  @Input()\n  public options: editor.IStandaloneEditorConstructionOptions = {};\n\n  @Input()\n  public disableMiniMap = false;\n\n  @Input()\n  public disableAutoFormat = false;\n\n  @Input()\n  @HostBinding('class.single-line')\n  public singleLineMode = false;\n\n  public loaded$ = new ReplaySubject<boolean>(1);\n\n  private defaultOptions: editor.IStandaloneEditorConstructionOptions = {\n    contextmenu: false,\n    minimap: {\n      enabled: true,\n    },\n    automaticLayout: true,\n    scrollBeyondLastLine: false,\n  };\n\n  public value = '';\n  public readOnly = false;\n  public standaloneCodeEditor?: editor.IStandaloneCodeEditor;\n  private textModel?: editor.ITextModel;\n  private toDisposes: Monaco.IDisposable[] = [];\n\n  private isMonacoEditorReady: WritableSignal<{ isSetup: boolean; hasFirstValue: boolean }> = signal({\n    isSetup: false,\n    hasFirstValue: false,\n  });\n\n  protected _onChange: (_value: string | null) => void = () => ({});\n\n  protected _onTouched: () => void = () => ({});\n  private unsubscribe$ = new Subject<void>();\n\n  constructor(\n    public readonly hostElement: ElementRef,\n    @Inject(GIO_MONACO_EDITOR_CONFIG) private readonly config: GioMonacoEditorConfig,\n    private readonly monacoEditorService: GioMonacoEditorService,\n    private readonly languageJsonService: GioLanguageJsonService,\n    private readonly languageSpelService: GioLanguageElService,\n    private readonly changeDetectorRef: ChangeDetectorRef,\n    private readonly ngZone: NgZone,\n    @Optional() @Self() public readonly ngControl: NgControl,\n  ) {\n    if (this.ngControl) {\n      // Set the value accessor directly (instead of providing\n      // NG_VALUE_ACCESSOR) to avoid running into a circular import\n      this.ngControl.valueAccessor = this;\n    }\n    this.monacoEditorService.loadEditor();\n\n    effect(() => {\n      const { isSetup, hasFirstValue } = this.isMonacoEditorReady();\n      if (isSetup && hasFirstValue) {\n        if (this.textModel) {\n          this.textModel.setValue(this.value);\n        }\n\n        this.updateModelLanguage();\n        this.autoformatValue();\n      }\n    });\n  }\n\n  public ngAfterViewInit() {\n    // Wait until monaco editor is available\n    this.monacoEditorService.loaded$.pipe(takeUntil(this.unsubscribe$)).subscribe(({ monaco }) => {\n      this.setupEditor(monaco);\n      this.isMonacoEditorReady.update(({ hasFirstValue }) => ({ isSetup: true, hasFirstValue }));\n\n      this.loaded$.next(false);\n      this.changeDetectorRef.detectChanges();\n    });\n  }\n\n  public ngOnDestroy() {\n    this.toDisposes.forEach(d => d.dispose());\n\n    if (this.standaloneCodeEditor) {\n      this.standaloneCodeEditor.dispose();\n      this.standaloneCodeEditor = undefined;\n    }\n\n    if (this.textModel) {\n      this.textModel.dispose();\n      this.textModel = undefined;\n    }\n    this.unsubscribe$.next();\n    this.unsubscribe$.complete();\n  }\n\n  // From ControlValueAccessor interface\n  public writeValue(_value: string | null): void {\n    if (_value) {\n      this.value = isString(_value) ? _value : JSON.stringify(_value);\n      this.isMonacoEditorReady.update(({ isSetup }) => ({ isSetup, hasFirstValue: true }));\n    }\n  }\n\n  // From ControlValueAccessor interface\n  public registerOnChange(fn: (_value: string | null) => void): void {\n    this._onChange = fn;\n  }\n\n  // From ControlValueAccessor interface\n  public registerOnTouched(fn: () => void): void {\n    this._onTouched = fn;\n  }\n\n  // From ControlValueAccessor interface\n  public setDisabledState(isDisabled: boolean): void {\n    this.readOnly = isDisabled;\n\n    if (this.standaloneCodeEditor) {\n      this.standaloneCodeEditor.updateOptions({\n        readOnly: isDisabled,\n      });\n    }\n  }\n\n  private setupEditor(monaco: typeof Monaco) {\n    if (!this.hostElement) {\n      throw new Error('No editor ref found.');\n    }\n\n    const domElement = this.hostElement.nativeElement;\n\n    const settings = {\n      value: this.value,\n      language: this.languageConfig?.language ?? (isJsonString(this.value) ? 'json' : 'plaintext'),\n      uri: `code-${uniqueId()}`,\n    };\n\n    this.ngZone.runOutsideAngular(() => {\n      this.textModel = monaco.editor.createModel(settings.value, settings.language, monaco.Uri.parse(settings.uri));\n    });\n\n    const options = Object.assign({}, this.defaultOptions, this.options, {\n      readOnly: !this.ngControl && 'readOnly' in this.options ? this.options.readOnly : this.readOnly,\n      theme: this.config.theme ?? 'vs',\n      model: this.textModel,\n      minimap: {\n        enabled: !this.disableMiniMap,\n      },\n    });\n\n    this.standaloneCodeEditor = monaco.editor.create(domElement, {\n      ...options,\n    });\n\n    if (this.singleLineMode) {\n      this.standaloneCodeEditor?.addAction({\n        id: 'custom.action',\n        label: 'custom action',\n        keybindings: [monaco.KeyCode.Enter],\n        precondition: '!suggestWidgetVisible && !renameInputVisible && !inSnippetMode && !quickFixWidgetVisible',\n        run: () => {\n          // Ignore Enter key in single line mode when writing\n          return;\n        },\n      });\n    }\n\n    const onDidChangeContent = this.textModel?.onDidChangeContent(() => {\n      const textModelValue = this.textModel?.getValue() ?? '';\n      if (this.singleLineMode) {\n        // If value has \\n, \\r or \\r\\n, remove them\n        // Useful to clear line breaks when pasting text\n        const hasLineBreak = new RegExp(/(\\r\\n|\\n|\\r)/gm);\n        if (hasLineBreak.test(textModelValue)) {\n          const currentPosition = this.standaloneCodeEditor?.getPosition();\n          setTimeout(() => {\n            this.standaloneCodeEditor?.pushUndoStop();\n            this.textModel?.setValue(textModelValue.replace(/(\\r\\n|\\n|\\r)/gm, ''));\n            if (currentPosition) {\n              this.standaloneCodeEditor?.setPosition(currentPosition);\n            }\n            this.standaloneCodeEditor?.popUndoStop();\n          }, 0);\n          return;\n        }\n      }\n\n      this.ngZone.run(() => {\n        if (!this.readOnly && !isEqual(this.value, textModelValue)) {\n          setTimeout(() => {\n            this.value = textModelValue;\n            this._onChange(textModelValue);\n            this._onTouched();\n          }, 0);\n        }\n      });\n    });\n\n    if (this.singleLineMode) {\n      // Source : https://farzadyz.com/blog/single-line-monaco-editor\n      this.standaloneCodeEditor?.updateOptions({\n        // quickSuggestions: false,\n        fixedOverflowWidgets: true,\n        acceptSuggestionOnEnter: 'on',\n        hover: {\n          delay: 100,\n        },\n        roundedSelection: false,\n        contextmenu: false,\n        cursorStyle: 'line-thin',\n        links: false,\n        find: {\n          addExtraSpaceOnTop: false,\n          autoFindInSelection: 'never',\n          seedSearchStringFromSelection: 'never',\n        },\n        fontSize: 14,\n        fontWeight: 'normal',\n        overviewRulerLanes: 0,\n        scrollBeyondLastColumn: 0,\n        wordWrap: 'on',\n        minimap: {\n          enabled: false,\n        },\n        lineNumbers: 'off',\n        hideCursorInOverviewRuler: true,\n        overviewRulerBorder: false,\n        glyphMargin: false,\n        folding: false,\n        lineDecorationsWidth: 0,\n        lineNumbersMinChars: 0,\n        renderLineHighlight: 'none',\n        scrollbar: {\n          horizontal: 'hidden',\n          vertical: 'hidden',\n          alwaysConsumeMouseWheel: false,\n        },\n      });\n    }\n\n    const onDidBlurEditorWidget = this.standaloneCodeEditor?.onDidBlurEditorWidget(() => {\n      this.ngZone.run(() => {\n        if (!this.readOnly) this._onTouched();\n      });\n    });\n\n    this.toDisposes = [onDidChangeContent, onDidBlurEditorWidget].filter(d => !!d) as Monaco.IDisposable[];\n\n    this.setupLanguage(settings.uri, this.languageConfig);\n  }\n\n  private setupLanguage(uri: string, languageConfig?: MonacoEditorLanguageConfig) {\n    if (!languageConfig) {\n      return;\n    }\n\n    switch (languageConfig.language) {\n      case 'json':\n        if (languageConfig.schemas) {\n          this.languageJsonService.addSchemas(uri, languageConfig.schemas);\n        }\n        break;\n      case 'spel':\n        if (languageConfig.schema) {\n          this.languageSpelService.setSchema(languageConfig.schema);\n        }\n        break;\n      default:\n        break;\n    }\n  }\n\n  private updateModelLanguage() {\n    const languageId = this.languageConfig?.language ?? (isJsonString(this.value) ? 'json' : 'plaintext');\n    if (this.textModel && window.monaco) {\n      window.monaco.editor.setModelLanguage(this.textModel, languageId);\n    }\n  }\n\n  private autoformatValue() {\n    if (!this.disableAutoFormat) {\n      setTimeout(() => {\n        const previousReadOnlyState = this.options.readOnly || this.readOnly;\n        this.standaloneCodeEditor?.updateOptions({ readOnly: false });\n        this.standaloneCodeEditor\n          ?.getAction('editor.action.formatDocument')\n          ?.run()\n          .finally(() => {\n            this.standaloneCodeEditor?.updateOptions({ readOnly: previousReadOnlyState });\n            this.changeDetectorRef.detectChanges();\n          });\n      }, 80);\n    }\n  }\n}\n\nconst isJsonString = (str: string): boolean => {\n  try {\n    JSON.parse(str);\n  } catch (e) {\n    return false;\n  }\n  return true;\n};\n"]}

package/esm2022/lib/gio-monaco-editor/gio-monaco-editor.harness.mjs

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { TestBed } from '@angular/core/testing';
+import { GioMonacoEditorComponent } from './gio-monaco-editor.component';
+import { GioMonacoEditorModule } from './gio-monaco-editor.module';
+import { GioMonacoEditorTestingComponent } from './gio-monaco-editor.testing.component';
+export const ConfigureTestingGioMonacoEditor = () => {
+    // Hack to replace the default gio-monaco-editor component with fake one for testing purpose.
+    try {
+        TestBed.overrideModule(GioMonacoEditorModule, {
+            remove: {
+                declarations: [GioMonacoEditorComponent],
+                exports: [GioMonacoEditorComponent],
+            },
+            add: {
+                declarations: [GioMonacoEditorTestingComponent],
+                exports: [GioMonacoEditorTestingComponent],
+            },
+        });
+    }
+    catch (e) {
+        // Do nothing
+    }
+};
+ConfigureTestingGioMonacoEditor();
+export class GioMonacoEditorHarness extends ComponentHarness {
+    static { this.hostSelector = 'gio-monaco-editor'; }
+    constructor(locatorFactory) {
+        super(locatorFactory);
+        this.getInputEl = this.locatorFor('input');
+    }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `GioMonacoEditorHarness` that meets
+     * certain criteria.
+     *
+     * @param options Options for filtering which input instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(GioMonacoEditorHarness, options);
+    }
+    async setValue(value) {
+        const inputEl = await this.getInputEl();
+        await inputEl.clear();
+        await inputEl.sendKeys(value);
+    }
+    async getValue() {
+        const inputEl = await this.getInputEl();
+        return inputEl.getProperty('value');
+    }
+    async isDisabled() {
+        const inputEl = await this.getInputEl();
+        return inputEl.getProperty('disabled');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/gio-monaco-editor/gio-monaco-editor.module.mjs

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { GioClipboardModule } from '../gio-clipboard/gio-clipboard.module';
+import { GioMonacoEditorFormFieldDirective } from './gio-monaco-editor-form-field.directive';
+import { GioMonacoEditorComponent } from './gio-monaco-editor.component';
+import { GIO_MONACO_EDITOR_CONFIG } from './models/GioMonacoEditorConfig';
+import { GioMonacoClipboardCopyComponent } from './gio-monaco-clipboard-copy.component';
+import * as i0 from "@angular/core";
+export class GioMonacoEditorModule {
+    static forRoot(config) {
+        return {
+            ngModule: GioMonacoEditorModule,
+            providers: [
+                {
+                    provide: GIO_MONACO_EDITOR_CONFIG,
+                    useValue: config,
+                },
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioMonacoEditorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.4", ngImport: i0, type: GioMonacoEditorModule, declarations: [GioMonacoEditorComponent, GioMonacoEditorFormFieldDirective, GioMonacoClipboardCopyComponent], imports: [CommonModule, ReactiveFormsModule, GioClipboardModule], exports: [GioMonacoEditorComponent, GioMonacoEditorFormFieldDirective, GioMonacoClipboardCopyComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioMonacoEditorModule, providers: [
+            {
+                provide: GIO_MONACO_EDITOR_CONFIG,
+                useValue: {},
+            },
+        ], imports: [CommonModule, ReactiveFormsModule, GioClipboardModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioMonacoEditorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, ReactiveFormsModule, GioClipboardModule],
+                    declarations: [GioMonacoEditorComponent, GioMonacoEditorFormFieldDirective, GioMonacoClipboardCopyComponent],
+                    exports: [GioMonacoEditorComponent, GioMonacoEditorFormFieldDirective, GioMonacoClipboardCopyComponent],
+                    providers: [
+                        {
+                            provide: GIO_MONACO_EDITOR_CONFIG,
+                            useValue: {},
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/gio-monaco-editor/gio-monaco-editor.testing.component.mjs

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2023 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component } from '@angular/core';
+import { GioMonacoEditorComponent } from './gio-monaco-editor.component';
+import * as i0 from "@angular/core";
+/**
+ * This component is used to test the GioMonacoEditorComponent.
+ * This component simulates monaco editor with a simple input.
+ */
+export class GioMonacoEditorTestingComponent extends GioMonacoEditorComponent {
+    get getValue() {
+        return this.value;
+    }
+    changeValue(value) {
+        this._onTouched();
+        this._onChange(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioMonacoEditorTestingComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", type: GioMonacoEditorTestingComponent, isStandalone: false, selector: "gio-monaco-editor", usesInheritance: true, ngImport: i0, template: '<input type="text" [value]="getValue" [disabled]="readOnly" (input)="changeValue($any($event).target?.value)" />', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioMonacoEditorTestingComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'gio-monaco-editor',
+                    template: '<input type="text" [value]="getValue" [disabled]="readOnly" (input)="changeValue($any($event).target?.value)" />',
+                    standalone: false,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2lvLW1vbmFjby1lZGl0b3IudGVzdGluZy5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1wYXJ0aWNsZXMtYW5ndWxhci9zcmMvbGliL2dpby1tb25hY28tZWRpdG9yL2dpby1tb25hY28tZWRpdG9yLnRlc3RpbmcuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUxQyxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQzs7QUFFekU7OztHQUdHO0FBTUgsTUFBTSxPQUFPLCtCQUFnQyxTQUFRLHdCQUF3QjtJQUMzRSxJQUFXLFFBQVE7UUFDakIsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBQ3BCLENBQUM7SUFFTSxXQUFXLENBQUMsS0FBYTtRQUM5QixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDbEIsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUN4QixDQUFDOzhHQVJVLCtCQUErQjtrR0FBL0IsK0JBQStCLHFHQUhoQyxrSEFBa0g7OzJGQUdqSCwrQkFBK0I7a0JBTDNDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLG1CQUFtQjtvQkFDN0IsUUFBUSxFQUFFLGtIQUFrSDtvQkFDNUgsVUFBVSxFQUFFLEtBQUs7aUJBQ2xCIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoQykgMjAyMyBUaGUgR3Jhdml0ZWUgdGVhbSAoaHR0cDovL2dyYXZpdGVlLmlvKVxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cbmltcG9ydCB7IENvbXBvbmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBHaW9Nb25hY29FZGl0b3JDb21wb25lbnQgfSBmcm9tICcuL2dpby1tb25hY28tZWRpdG9yLmNvbXBvbmVudCc7XG5cbi8qKlxuICogVGhpcyBjb21wb25lbnQgaXMgdXNlZCB0byB0ZXN0IHRoZSBHaW9Nb25hY29FZGl0b3JDb21wb25lbnQuXG4gKiBUaGlzIGNvbXBvbmVudCBzaW11bGF0ZXMgbW9uYWNvIGVkaXRvciB3aXRoIGEgc2ltcGxlIGlucHV0LlxuICovXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdnaW8tbW9uYWNvLWVkaXRvcicsXG4gIHRlbXBsYXRlOiAnPGlucHV0IHR5cGU9XCJ0ZXh0XCIgW3ZhbHVlXT1cImdldFZhbHVlXCIgW2Rpc2FibGVkXT1cInJlYWRPbmx5XCIgKGlucHV0KT1cImNoYW5nZVZhbHVlKCRhbnkoJGV2ZW50KS50YXJnZXQ/LnZhbHVlKVwiIC8+JyxcbiAgc3RhbmRhbG9uZTogZmFsc2UsXG59KVxuZXhwb3J0IGNsYXNzIEdpb01vbmFjb0VkaXRvclRlc3RpbmdDb21wb25lbnQgZXh0ZW5kcyBHaW9Nb25hY29FZGl0b3JDb21wb25lbnQge1xuICBwdWJsaWMgZ2V0IGdldFZhbHVlKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMudmFsdWU7XG4gIH1cblxuICBwdWJsaWMgY2hhbmdlVmFsdWUodmFsdWU6IHN0cmluZykge1xuICAgIHRoaXMuX29uVG91Y2hlZCgpO1xuICAgIHRoaXMuX29uQ2hhbmdlKHZhbHVlKTtcbiAgfVxufVxuIl19

package/esm2022/lib/gio-monaco-editor/models/GioMonacoEditorConfig.mjs

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2023 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { InjectionToken } from '@angular/core';
+export const GIO_MONACO_EDITOR_CONFIG = new InjectionToken('gio-monaco-editor-config');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR2lvTW9uYWNvRWRpdG9yQ29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktcGFydGljbGVzLWFuZ3VsYXIvc3JjL2xpYi9naW8tbW9uYWNvLWVkaXRvci9tb2RlbHMvR2lvTW9uYWNvRWRpdG9yQ29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQVMvQyxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBRyxJQUFJLGNBQWMsQ0FBd0IsMEJBQTBCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKEMpIDIwMjMgVGhlIEdyYXZpdGVlIHRlYW0gKGh0dHA6Ly9ncmF2aXRlZS5pbylcbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBNb25hY29FZGl0b3JUaGVtZSB9IGZyb20gJy4vTW9uYWNvRWRpdG9yVGhlbWUnO1xuXG5leHBvcnQgdHlwZSBHaW9Nb25hY29FZGl0b3JDb25maWcgPSB7XG4gIGJhc2VVcmw/OiBzdHJpbmc7XG4gIHRoZW1lPzogTW9uYWNvRWRpdG9yVGhlbWU7XG59O1xuXG5leHBvcnQgY29uc3QgR0lPX01PTkFDT19FRElUT1JfQ09ORklHID0gbmV3IEluamVjdGlvblRva2VuPEdpb01vbmFjb0VkaXRvckNvbmZpZz4oJ2dpby1tb25hY28tZWRpdG9yLWNvbmZpZycpO1xuIl19