@gravitee/ui-particles-angular 12.0.2 → 12.1.0-apim-3970-schematics-3dc6ff4

package/fesm2022/gravitee-ui-particles-angular.mjs

@@ -2872,6 +2872,341 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.3", ngImpor
                 }]
         }], ctorParameters: () => [{ type: GioMonacoEditorService }] });
 
+const SCHEMA_REF_BASE = '#/$defs/';
+function getKeywords(schema, keywords = new Set()) {
+    const properties = schema.properties || {};
+    const defs = schema.$defs || {};
+    for (const property of Object.values(defs)) {
+        if (property.properties) {
+            getKeywords(property, keywords);
+        }
+    }
+    for (const [name, property] of Object.entries(properties)) {
+        keywords.add(name);
+        if (property.properties) {
+            getKeywords(property, keywords);
+        }
+    }
+    return Array.from(keywords);
+}
+/**
+ * Build suggestions for autocompletion based on a JSON schema definition and a property path
+ *
+ * @param schema an object model defined as a JSON schema following the 2020-12 specification
+ * @param path the property path to inspect. If the property path contains '.', then root properties will be returned
+ */
+function getSuggestions(schema, path) {
+    const propertyNames = [...path];
+    const propertyName = propertyNames.shift();
+    if (propertyName === '.') {
+        return buildSuggestions(schema, schema);
+    }
+    const property = getProperty(schema, propertyName);
+    if (!property) {
+        return {
+            properties: [],
+            additionalProperties: {},
+            items: {},
+        };
+    }
+    const newSchema = mergeSchemaWithProperties(schema, property);
+    if (propertyNames.length > 0) {
+        return getSuggestions(newSchema, propertyNames);
+    }
+    return buildSuggestions(newSchema, property);
+}
+function resolveReference(ref, defs = {}) {
+    const refName = ref.substring(SCHEMA_REF_BASE.length);
+    const resolved = defs[refName];
+    if (resolved && resolved.$ref) {
+        return resolveReference(resolved.$ref, defs);
+    }
+    return resolved || {};
+}
+function resolveType(property, defs) {
+    if (property.$ref) {
+        const resolved = resolveReference(property.$ref, defs);
+        return resolveType(resolved, defs);
+    }
+    if (property.additionalProperties || property.items) {
+        const stringMap = 'map<string, ';
+        const array = 'array<';
+        let type = property.additionalProperties ? stringMap : array;
+        let copy = property.additionalProperties || property.items;
+        while (copy.additionalProperties || copy.items) {
+            type += copy.additionalProperties ? stringMap : array;
+            copy = copy.additionalProperties || copy.items;
+        }
+        return `${type}${copy.type}>`;
+    }
+    return property.type;
+}
+function getProperty(schema, propertyName = String()) {
+    if (schema.properties && schema.properties[propertyName]) {
+        return schema.properties[propertyName];
+    }
+    if (schema.$ref && schema.$defs) {
+        const property = resolveReference(schema.$ref, schema.$defs);
+        if (property && property.properties) {
+            return property.properties[propertyName];
+        }
+    }
+    return {};
+}
+function buildIndexableSuggestion(property) {
+    return {
+        properties: [],
+        additionalProperties: property.additionalProperties || {},
+        items: property.items || {},
+    };
+}
+function buildSuggestions(schema, property) {
+    if (property.$ref && schema.$defs) {
+        const ref = resolveReference(property.$ref, schema.$defs);
+        return buildSuggestions(schema, ref);
+    }
+    if (property.additionalProperties || property.items) {
+        return buildIndexableSuggestion(property);
+    }
+    const properties = property.properties || {};
+    return {
+        properties: mapSuggestions(properties, schema.$defs),
+        additionalProperties: {},
+        items: {},
+    };
+}
+function mapSuggestions(properties, defs) {
+    return Object.entries(properties).map(([name, property]) => {
+        return {
+            name,
+            type: resolveType(property, defs),
+        };
+    });
+}
+function mergeSchemaWithProperties(schema, property) {
+    return { ...schema, ...property };
+}
+
+/*
+ * Copyright (C) 2024 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.
+ */
+const SPEL_LANG_ID = 'spel';
+function getPropertyPath(model, position) {
+    const line = model.getValueInRange({
+        startLineNumber: position.lineNumber,
+        startColumn: 0,
+        endLineNumber: position.lineNumber,
+        endColumn: position.column,
+    });
+    // get last valid el expression (most right hand side of the current line)
+    const lastExpression = line.split('#').filter(Boolean).pop();
+    if (!lastExpression) {
+        return [];
+    }
+    // get expression left hand side
+    const lastExpressionLHS = lastExpression.split(/\s+/).filter(Boolean).shift();
+    if (!lastExpressionLHS) {
+        return [];
+    }
+    return (lastExpressionLHS
+        // remove special characters
+        .replace(/\W/g, ' ')
+        // normalize spaces
+        .replace(/\s+/g, ' ')
+        .trim()
+        .split(/\s/));
+}
+class GioLanguageElService {
+    ngOnDestroy() {
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+    constructor(codeEditorService) {
+        this.unsubscribe$ = new Subject();
+        this.context = {
+            schema: {},
+            keywords: [],
+        };
+        this.schema = {};
+        this.keywords = [];
+        codeEditorService.loaded$.pipe(takeUntil(this.unsubscribe$)).subscribe(event => {
+            this.setup(event.monaco);
+        });
+    }
+    setup(monaco) {
+        if (!monaco) {
+            throw new Error('Monaco is not loaded');
+        }
+        monaco.languages.register({ id: SPEL_LANG_ID });
+        monaco.languages.setLanguageConfiguration(SPEL_LANG_ID, {
+            brackets: [
+                ['{', '}'],
+                ['(', ')'],
+                ['[', ']'],
+            ],
+            autoClosingPairs: [
+                {
+                    open: "'",
+                    close: "'",
+                },
+                {
+                    open: '"',
+                    close: '"',
+                },
+                {
+                    open: '(',
+                    close: ')',
+                },
+                {
+                    open: '{',
+                    close: '}',
+                },
+                {
+                    open: '[',
+                    close: ']',
+                },
+            ],
+            surroundingPairs: [
+                {
+                    open: "'",
+                    close: "'",
+                },
+                {
+                    open: '"',
+                    close: '"',
+                },
+                {
+                    open: '(',
+                    close: ')',
+                },
+                {
+                    open: '{',
+                    close: '}',
+                },
+            ],
+        });
+        const schema = this.schema;
+        const keywords = this.keywords;
+        monaco.languages.setMonarchTokensProvider(SPEL_LANG_ID, {
+            keywords,
+            operators: ['=', '>', '<', '!', '?', ':', '==', '<=', '>=', '!=', '&&', '||', '++', '--', '+', '-', '*', '/', '^', '%'],
+            tokenizer: {
+                root: [
+                    [
+                        /@?[a-zA-Z][\w$]*/,
+                        {
+                            cases: {
+                                '@keywords': 'keyword',
+                                '@operators': 'operator',
+                                '@default': 'variable',
+                            },
+                        },
+                    ],
+                    [/["'].*?["']/, 'string'],
+                    [/"([^"\\]|\\.)*$/, 'string.invalid'],
+                    [/#/, 'number'],
+                    // eslint-disable-next-line no-useless-escape
+                    [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+                    [/0[xX][0-9a-fA-F]+/, 'number.hex'],
+                    [/\d+/, 'number'],
+                ],
+            },
+        });
+        monaco.languages.registerCompletionItemProvider(SPEL_LANG_ID, {
+            provideCompletionItems(model, position, context) {
+                const word = model.getWordUntilPosition(position);
+                const mapPropertyKind = (propertySuggestion) => {
+                    switch (propertySuggestion.type) {
+                        case 'object':
+                            return monaco.languages.CompletionItemKind.Struct;
+                        case 'string':
+                            return monaco.languages.CompletionItemKind.Text;
+                        default:
+                            return monaco.languages.CompletionItemKind.Field;
+                    }
+                };
+                const mapPropertySuggestion = (propertySuggestion) => {
+                    return {
+                        label: propertySuggestion.name,
+                        kind: mapPropertyKind(propertySuggestion),
+                        insertText: propertySuggestion.name,
+                        detail: propertySuggestion.type,
+                        range: {
+                            startLineNumber: position.lineNumber,
+                            endLineNumber: position.lineNumber,
+                            startColumn: word.startColumn,
+                            endColumn: word.endColumn,
+                        },
+                    };
+                };
+                const mapIndexableSuggestions = (suggestion) => {
+                    return (suggestion.enum?.map(name => {
+                        return {
+                            label: name,
+                            kind: monaco.languages.CompletionItemKind.Enum,
+                            insertText: `"${name}"`,
+                            detail: 'enum',
+                            range: {
+                                startLineNumber: position.lineNumber,
+                                endLineNumber: position.lineNumber,
+                                startColumn: word.startColumn,
+                                endColumn: word.endColumn,
+                            },
+                        };
+                    }) || []);
+                };
+                if (context.triggerCharacter === '#') {
+                    return {
+                        suggestions: getSuggestions(schema, ['.']).properties.map(mapPropertySuggestion).sort(),
+                    };
+                }
+                if (context.triggerCharacter === '[') {
+                    const path = getPropertyPath(model, position);
+                    const suggestions = getSuggestions(schema, path);
+                    if (suggestions.additionalProperties && suggestions.additionalProperties.enum) {
+                        return {
+                            suggestions: mapIndexableSuggestions(suggestions.additionalProperties),
+                        };
+                    }
+                }
+                if (context.triggerCharacter === '.') {
+                    const path = getPropertyPath(model, position);
+                    const suggestions = getSuggestions(schema, path).properties.map(mapPropertySuggestion).sort();
+                    return {
+                        suggestions,
+                    };
+                }
+                return { suggestions: [] };
+            },
+            triggerCharacters: ['#', '.', '['],
+        });
+    }
+    setSchema(schema) {
+        Object.assign(this.schema, schema);
+        this.keywords.push(...getKeywords(schema));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.3", ngImport: i0, type: GioLanguageElService, deps: [{ token: GioMonacoEditorService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.3", ngImport: i0, type: GioLanguageElService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.3", ngImport: i0, type: GioLanguageElService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: GioMonacoEditorService }] });
+
 /*
  * Copyright (C) 2023 The Gravitee team (http://gravitee.io)
  *
@@ -2888,11 +3223,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.3", ngImpor
  * limitations under the License.
  */
 class GioMonacoEditorComponent {
-    constructor(hostElement, config, monacoEditorService, languageJsonService, changeDetectorRef, ngZone, ngControl) {
+    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;
@@ -3022,11 +3358,16 @@ class GioMonacoEditorComponent {
                     this.languageJsonService.addSchemas(uri, languageConfig.schemas);
                 }
                 break;
+            case 'spel':
+                if (languageConfig.schema) {
+                    this.languageSpelService.setSchema(languageConfig.schema);
+                }
+                break;
             default:
                 break;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.3", ngImport: i0, type: GioMonacoEditorComponent, deps: [{ token: i0.ElementRef }, { token: GIO_MONACO_EDITOR_CONFIG }, { token: GioMonacoEditorService }, { token: GioLanguageJsonService }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i1$1.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.3", ngImport: i0, type: GioMonacoEditorComponent, deps: [{ token: i0.ElementRef }, { token: GIO_MONACO_EDITOR_CONFIG }, { token: GioMonacoEditorService }, { token: GioLanguageJsonService }, { token: GioLanguageElService }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i1$1.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component }); }
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.3", type: GioMonacoEditorComponent, selector: "gio-monaco-editor", inputs: { languageConfig: "languageConfig", options: "options", disableMiniMap: "disableMiniMap" }, 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-context(.hidden){opacity:0}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.3", ngImport: i0, type: GioMonacoEditorComponent, decorators: [{
@@ -3035,7 +3376,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.3", ngImpor
         }], ctorParameters: () => [{ type: i0.ElementRef }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [GIO_MONACO_EDITOR_CONFIG]
-                }] }, { type: GioMonacoEditorService }, { type: GioLanguageJsonService }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i1$1.NgControl, decorators: [{
+                }] }, { type: GioMonacoEditorService }, { type: GioLanguageJsonService }, { type: GioLanguageElService }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i1$1.NgControl, decorators: [{
                     type: Optional
                 }, {
                     type: Self