@gravitee/ui-particles-angular 5.11.0 → 5.12.0-monaco-editor-80f03f5

package/esm2020/lib/gio-monaco-editor/gio-monaco-editor.harness.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 { 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.
+TestBed.overrideModule(GioMonacoEditorModule, {
+    remove: {
+        declarations: [GioMonacoEditorComponent],
+        exports: [GioMonacoEditorComponent],
+    },
+    add: {
+        declarations: [GioMonacoEditorTestingComponent],
+        exports: [GioMonacoEditorTestingComponent],
+    },
+});
+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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

package/esm2020/lib/public-api.mjs

@@ -47,4 +47,9 @@ export * from './gio-form-json-schema/model/GioJsonSchema';
 export * from './gio-form-slide-toogle/gio-form-slide-toggle.component';
 export * from './gio-form-slide-toogle/gio-form-slide-toggle.module';
 export * from './gio-form-slide-toogle/gio-form-label.directive';
-//# sourceMappingURL=data:application/json;base64,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
+export * from './gio-form-focus-first-invalid/gio-form-focus-first-invalid.directive';
+export * from './gio-form-focus-first-invalid/gio-form-focus-first-invalid.module';
+export * from './gio-monaco-editor/gio-monaco-editor.component';
+export * from './gio-monaco-editor/gio-monaco-editor.module';
+export * from './gio-monaco-editor/gio-monaco-editor.harness';
+//# sourceMappingURL=data:application/json;base64,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