@gravitee/ui-particles-angular 5.13.0 → 5.14.0

package/esm2020/lib/gio-form-json-schema/model/GioJsonSchema.mjs

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/gio-form-json-schema/type-component/object-type.component.mjs

@@ -38,7 +38,7 @@ GioFjsObjectTypeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.
         <formly-field *ngFor="let f of field.fieldGroup" class="wrapper__fields__field" [field]="f"></formly-field>
       </div>
     </div>
-  `, isInline: true, styles: [".wrapper{display:flex;flex-direction:column}.wrapper__title{font:600 18px/24px Golos UI,Roboto,Helvetica Neue,sans-serif;letter-spacing:.4px;margin-bottom:16px}.wrapper:empty{display:none}.wrapper__error{font:400 12px/16px Golos UI,Roboto,Helvetica Neue,sans-serif;letter-spacing:normal;color:#ec4899}.wrapper__fields{padding:8px;border:1px solid #d3d5dc;border-radius:8px}.wrapper__fields:has(> .wrapper__fields__field:only-child):has(> .wrapper__fields__field:empty){display:none}.wrapper__fields__field:empty{display:none}.wrapper__fields__field+.wrapper__fields__field:not(:empty){display:block;margin-top:8px}\n"], components: [{ type: i1.ɵFormlyValidationMessage, selector: "formly-validation-message", inputs: ["field"] }, { type: i1.FormlyField, selector: "formly-field", inputs: ["field"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+  `, isInline: true, styles: [".wrapper{display:flex;flex-direction:column}.wrapper__title{font:600 18px/24px Golos UI,Roboto,Helvetica Neue,sans-serif;letter-spacing:.4px;margin-bottom:16px}.wrapper:empty{display:none}.wrapper__error{font:400 12px/16px Golos UI,Roboto,Helvetica Neue,sans-serif;letter-spacing:normal;color:#ec4899}.wrapper__fields{padding:8px;border:1px solid #d3d5dc;border-radius:8px}.wrapper__fields:empty{display:none}.wrapper__fields:has(> .wrapper__fields__field:only-child):has(> .wrapper__fields__field:empty){display:none}.wrapper__fields__field:empty{display:none}.wrapper__fields__field+.wrapper__fields__field:not(:empty){display:block;margin-top:8px}\n"], components: [{ type: i1.ɵFormlyValidationMessage, selector: "formly-validation-message", inputs: ["field"] }, { type: i1.FormlyField, selector: "formly-field", inputs: ["field"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioFjsObjectTypeComponent, decorators: [{
             type: Component,
             args: [{ selector: 'gio-fjs-object-type', template: `
@@ -52,6 +52,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImpo
         <formly-field *ngFor="let f of field.fieldGroup" class="wrapper__fields__field" [field]="f"></formly-field>
       </div>
     </div>
-  `, styles: [".wrapper{display:flex;flex-direction:column}.wrapper__title{font:600 18px/24px Golos UI,Roboto,Helvetica Neue,sans-serif;letter-spacing:.4px;margin-bottom:16px}.wrapper:empty{display:none}.wrapper__error{font:400 12px/16px Golos UI,Roboto,Helvetica Neue,sans-serif;letter-spacing:normal;color:#ec4899}.wrapper__fields{padding:8px;border:1px solid #d3d5dc;border-radius:8px}.wrapper__fields:has(> .wrapper__fields__field:only-child):has(> .wrapper__fields__field:empty){display:none}.wrapper__fields__field:empty{display:none}.wrapper__fields__field+.wrapper__fields__field:not(:empty){display:block;margin-top:8px}\n"] }]
+  `, styles: [".wrapper{display:flex;flex-direction:column}.wrapper__title{font:600 18px/24px Golos UI,Roboto,Helvetica Neue,sans-serif;letter-spacing:.4px;margin-bottom:16px}.wrapper:empty{display:none}.wrapper__error{font:400 12px/16px Golos UI,Roboto,Helvetica Neue,sans-serif;letter-spacing:normal;color:#ec4899}.wrapper__fields{padding:8px;border:1px solid #d3d5dc;border-radius:8px}.wrapper__fields:empty{display:none}.wrapper__fields:has(> .wrapper__fields__field:only-child):has(> .wrapper__fields__field:empty){display:none}.wrapper__fields__field:empty{display:none}.wrapper__fields__field+.wrapper__fields__field:not(:empty){display:block;margin-top:8px}\n"] }]
         }] });
 //# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,172 @@
+/*
+ * 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, forwardRef, Inject, Input } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { uniqueId } from 'lodash';
+import { 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 "@angular/common";
+export class GioMonacoEditorComponent {
+    constructor(config, monacoEditorService, languageJsonService, hostElement, changeDetectorRef, ngZone) {
+        this.config = config;
+        this.monacoEditorService = monacoEditorService;
+        this.languageJsonService = languageJsonService;
+        this.hostElement = hostElement;
+        this.changeDetectorRef = changeDetectorRef;
+        this.ngZone = ngZone;
+        this.options = {};
+        this.id = uniqueId('gio-monaco-editor-');
+        this.loading = true;
+        this.defaultOptions = {
+            contextmenu: false,
+            minimap: {
+                enabled: true,
+            },
+            automaticLayout: true,
+            scrollBeyondLastLine: false,
+        };
+        this.value = '';
+        this.readOnly = false;
+        this._onChange = () => ({});
+        this._onTouched = () => ({});
+        this.unsubscribe$ = new Subject();
+        this.monacoEditorService.loadEditor();
+    }
+    ngAfterViewInit() {
+        // Wait until monaco editor is available
+        this.monacoEditorService.loaded$.pipe(takeUntil(this.unsubscribe$)).subscribe(({ monaco }) => {
+            this.setupEditor(monaco);
+            this.loading = false;
+            this.changeDetectorRef.detectChanges();
+        });
+    }
+    ngOnDestroy() {
+        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 = _value;
+        }
+        if (this.textModel) {
+            this.textModel.setValue(this.value);
+        }
+    }
+    // From ControlValueAccessor interface
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    // From ControlValueAccessor interface
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    // From ControlValueAccessor interface
+    setDisabledState(isDisabled) {
+        this.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 ?? 'text',
+            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.readOnly,
+            theme: this.config.theme ?? 'vs',
+            model: this.textModel,
+        });
+        this.standaloneCodeEditor = monaco.editor.create(domElement, {
+            ...options,
+        });
+        this.textModel?.onDidChangeContent(() => {
+            const newValue = this.textModel?.getValue();
+            this.ngZone.run(() => {
+                newValue && this._onChange(newValue);
+                this._onTouched();
+            });
+        });
+        this.standaloneCodeEditor?.onDidBlurEditorWidget(() => {
+            this.ngZone.run(() => {
+                this._onTouched();
+            });
+        });
+        this.setupLanguage(settings.uri, this.languageConfig);
+    }
+    setupLanguage(uri, languageConfig) {
+        if (!languageConfig) {
+            return;
+        }
+        const { language } = languageConfig;
+        if (language) {
+            const lang = language.toLowerCase();
+            switch (lang) {
+                case 'json':
+                    if (languageConfig.schemas) {
+                        this.languageJsonService.addSchemas(uri, languageConfig.schemas);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+}
+GioMonacoEditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioMonacoEditorComponent, deps: [{ token: GIO_MONACO_EDITOR_CONFIG }, { token: i1.GioMonacoEditorService }, { token: i2.GioLanguageJsonService }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+GioMonacoEditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: GioMonacoEditorComponent, selector: "gio-monaco-editor", inputs: { languageConfig: "languageConfig", options: "options" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => GioMonacoEditorComponent),
+            multi: true,
+        },
+    ], ngImport: i0, template: ` <div *ngIf="loading">Loading...</div>`, isInline: true, styles: [":host{display:block;height:100%;min-height:150px}\n"], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioMonacoEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'gio-monaco-editor', template: ` <div *ngIf="loading">Loading...</div>`, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => GioMonacoEditorComponent),
+                            multi: true,
+                        },
+                    ], styles: [":host{display:block;height:100%;min-height:150px}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [GIO_MONACO_EDITOR_CONFIG]
+                }] }, { type: i1.GioMonacoEditorService }, { type: i2.GioLanguageJsonService }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }]; }, propDecorators: { languageConfig: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }] } });
+//# 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":"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","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 { AfterViewInit, ChangeDetectorRef, Component, ElementRef, forwardRef, Inject, Input, NgZone, OnDestroy } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { uniqueId } from 'lodash';\nimport Monaco, { editor } from 'monaco-editor';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { GioMonacoEditorConfig, GIO_MONACO_EDITOR_CONFIG } from './models/GioMonacoEditorConfig';\nimport { GioLanguageJsonService } from './services/gio-language-json.service';\nimport { GioMonacoEditorService } from './services/gio-monaco-editor.service';\n\nexport type MonacoEditorLanguageConfig = {\n  language: 'json';\n  schemas: { uri: string; schema: unknown }[];\n};\n\n@Component({\n  selector: 'gio-monaco-editor',\n  template: ` <div *ngIf=\"loading\">Loading...</div>`,\n  styleUrls: ['./gio-monaco-editor.component.scss'],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => GioMonacoEditorComponent),\n      multi: true,\n    },\n  ],\n})\nexport class GioMonacoEditorComponent implements ControlValueAccessor, AfterViewInit, OnDestroy {\n  @Input()\n  public languageConfig?: MonacoEditorLanguageConfig;\n\n  @Input()\n  public options: editor.IStandaloneEditorConstructionOptions = {};\n\n  public id = uniqueId('gio-monaco-editor-');\n\n  public loading = true;\n\n  private defaultOptions: editor.IStandaloneEditorConstructionOptions = {\n    contextmenu: false,\n    minimap: {\n      enabled: true,\n    },\n    automaticLayout: true,\n    scrollBeyondLastLine: false,\n  };\n\n  protected value = '';\n  protected readOnly = false;\n  private standaloneCodeEditor?: editor.IStandaloneCodeEditor;\n  private textModel?: editor.ITextModel;\n\n  protected _onChange: (_value: string | null) => void = () => ({});\n\n  protected _onTouched: () => void = () => ({});\n  private unsubscribe$ = new Subject<void>();\n\n  constructor(\n    @Inject(GIO_MONACO_EDITOR_CONFIG) private readonly config: GioMonacoEditorConfig,\n    private readonly monacoEditorService: GioMonacoEditorService,\n    private readonly languageJsonService: GioLanguageJsonService,\n    private readonly hostElement: ElementRef,\n    private readonly changeDetectorRef: ChangeDetectorRef,\n    private readonly ngZone: NgZone,\n  ) {\n    this.monacoEditorService.loadEditor();\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\n      this.loading = false;\n      this.changeDetectorRef.detectChanges();\n    });\n  }\n\n  public ngOnDestroy() {\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): void {\n    if (_value) {\n      this.value = _value;\n    }\n    if (this.textModel) {\n      this.textModel.setValue(this.value);\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\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 ?? 'text',\n      uri: `code-${uniqueId()}`,\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.readOnly,\n      theme: this.config.theme ?? 'vs',\n      model: this.textModel,\n    });\n\n    this.standaloneCodeEditor = monaco.editor.create(domElement, {\n      ...options,\n    });\n\n    this.textModel?.onDidChangeContent(() => {\n      const newValue = this.textModel?.getValue();\n      this.ngZone.run(() => {\n        newValue && this._onChange(newValue);\n        this._onTouched();\n      });\n    });\n\n    this.standaloneCodeEditor?.onDidBlurEditorWidget(() => {\n      this.ngZone.run(() => {\n        this._onTouched();\n      });\n    });\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    const { language } = languageConfig;\n\n    if (language) {\n      const lang = language.toLowerCase();\n\n      switch (lang) {\n        case 'json':\n          if (languageConfig.schemas) {\n            this.languageJsonService.addSchemas(uri, languageConfig.schemas);\n          }\n          break;\n        default:\n          break;\n      }\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,63 @@
+/*
+ * 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';
+// 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
+}
+export class GioMonacoEditorHarness extends ComponentHarness {
+    constructor() {
+        super(...arguments);
+        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');
+    }
+}
+GioMonacoEditorHarness.hostSelector = 'gio-monaco-editor';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,58 @@
+/*
+ * 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 { HttpClientModule } from '@angular/common/http';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { GioMonacoEditorComponent } from './gio-monaco-editor.component';
+import { GIO_MONACO_EDITOR_CONFIG } from './models/GioMonacoEditorConfig';
+import * as i0 from "@angular/core";
+export class GioMonacoEditorModule {
+    static forRoot(config) {
+        return {
+            ngModule: GioMonacoEditorModule,
+            providers: [
+                {
+                    provide: GIO_MONACO_EDITOR_CONFIG,
+                    useValue: config,
+                },
+            ],
+        };
+    }
+}
+GioMonacoEditorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioMonacoEditorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+GioMonacoEditorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioMonacoEditorModule, declarations: [GioMonacoEditorComponent], imports: [CommonModule, HttpClientModule, ReactiveFormsModule], exports: [GioMonacoEditorComponent] });
+GioMonacoEditorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioMonacoEditorModule, providers: [
+        {
+            provide: GIO_MONACO_EDITOR_CONFIG,
+            useValue: {},
+        },
+    ], imports: [[CommonModule, HttpClientModule, ReactiveFormsModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioMonacoEditorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, HttpClientModule, ReactiveFormsModule],
+                    declarations: [GioMonacoEditorComponent],
+                    exports: [GioMonacoEditorComponent],
+                    providers: [
+                        {
+                            provide: GIO_MONACO_EDITOR_CONFIG,
+                            useValue: {},
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,55 @@
+/*
+ * 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, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+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);
+    }
+}
+GioMonacoEditorTestingComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioMonacoEditorTestingComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+GioMonacoEditorTestingComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: GioMonacoEditorTestingComponent, selector: "gio-monaco-editor", providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => GioMonacoEditorTestingComponent),
+            multi: true,
+        },
+    ], usesInheritance: true, ngImport: i0, template: '<input type="text" [value]="getValue" (input)="changeValue($any($event).target?.value)" />', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioMonacoEditorTestingComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'gio-monaco-editor',
+                    template: '<input type="text" [value]="getValue" (input)="changeValue($any($event).target?.value)" />',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => GioMonacoEditorTestingComponent),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR2lvTW9uYWNvRWRpdG9yQ29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktcGFydGljbGVzLWFuZ3VsYXIvc3JjL2xpYi9naW8tbW9uYWNvLWVkaXRvci9tb2RlbHMvR2lvTW9uYWNvRWRpdG9yQ29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQVEvQyxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBRyxJQUFJLGNBQWMsQ0FBd0IsMEJBQTBCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKEMpIDIwMjMgVGhlIEdyYXZpdGVlIHRlYW0gKGh0dHA6Ly9ncmF2aXRlZS5pbylcbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBNb25hY29FZGl0b3JUaGVtZSB9IGZyb20gJy4vTW9uYWNvRWRpdG9yVGhlbWUnO1xuXG5leHBvcnQgdHlwZSBHaW9Nb25hY29FZGl0b3JDb25maWcgPSB7XG4gIHRoZW1lPzogTW9uYWNvRWRpdG9yVGhlbWU7XG59O1xuXG5leHBvcnQgY29uc3QgR0lPX01PTkFDT19FRElUT1JfQ09ORklHID0gbmV3IEluamVjdGlvblRva2VuPEdpb01vbmFjb0VkaXRvckNvbmZpZz4oJ2dpby1tb25hY28tZWRpdG9yLWNvbmZpZycpO1xuIl19

package/esm2020/lib/gio-monaco-editor/models/MonacoEditorTheme.mjs

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

package/esm2020/lib/gio-monaco-editor/services/gio-language-json.service.mjs

@@ -0,0 +1,71 @@
+/*
+ * 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 { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./gio-monaco-editor.service";
+export class GioLanguageJsonService {
+    constructor(codeEditorService) {
+        this.unsubscribe$ = new Subject();
+        codeEditorService.loaded$.pipe(takeUntil(this.unsubscribe$)).subscribe(event => {
+            this.setup(event.monaco);
+        });
+    }
+    ngOnDestroy() {
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+    setup(monaco) {
+        if (!monaco) {
+            throw new Error('Monaco is not loaded');
+        }
+        this.monaco = monaco;
+        const defaults = monaco.languages.json.jsonDefaults;
+        defaults.setDiagnosticsOptions({
+            validate: true,
+            allowComments: true,
+        });
+    }
+    addSchemas(id, definitions = []) {
+        if (!this.monaco) {
+            throw new Error('Monaco is not loaded');
+        }
+        const defaults = this.monaco.languages.json.jsonDefaults;
+        const options = defaults.diagnosticsOptions;
+        let schemas = definitions.map(({ uri, schema }) => ({
+            uri,
+            schema,
+            fileMatch: [id || '*.json'],
+        }));
+        if (options && options.schemas && options.schemas.length > 0) {
+            schemas = [...options.schemas, ...schemas];
+        }
+        defaults.setDiagnosticsOptions({
+            ...options,
+            schemas: schemas,
+        });
+    }
+}
+GioLanguageJsonService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioLanguageJsonService, deps: [{ token: i1.GioMonacoEditorService }], target: i0.ɵɵFactoryTarget.Injectable });
+GioLanguageJsonService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioLanguageJsonService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioLanguageJsonService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.GioMonacoEditorService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/gio-monaco-editor/services/gio-monaco-editor.service.mjs

@@ -0,0 +1,67 @@
+/*
+ * 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 { Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class GioMonacoEditorService {
+    constructor() {
+        this.loaded$ = new ReplaySubject(1);
+        this.loaded = false;
+    }
+    loadEditor() {
+        if (this.loaded) {
+            // Already loaded, do nothing.
+            return Promise.resolve();
+        }
+        this.loaded = true;
+        return new Promise(resolve => {
+            // Monaco is already loaded
+            if (typeof window.monaco === 'object') {
+                resolve();
+                return;
+            }
+            const onGotAmdLoader = () => {
+                // Load Monaco
+                window.require.config({ paths: { vs: 'assets/monaco-editor/min/vs' } });
+                window.require(['vs/editor/editor.main'], () => {
+                    resolve();
+                });
+            };
+            // Load AMD loader if necessary
+            if (!window.require) {
+                const loaderScript = document.createElement('script');
+                loaderScript.type = 'text/javascript';
+                loaderScript.src = 'assets/monaco-editor/min/vs/loader.js';
+                loaderScript.addEventListener('load', onGotAmdLoader);
+                document.body.appendChild(loaderScript);
+            }
+            else {
+                onGotAmdLoader();
+            }
+        }).then(() => {
+            this.loaded$.next({ monaco: window.monaco });
+        });
+    }
+}
+GioMonacoEditorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioMonacoEditorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+GioMonacoEditorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioMonacoEditorService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: GioMonacoEditorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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