@gooddata/sdk-ui-metric-component 11.65.0-alpha.13 → 11.65.0-alpha.15

package/esm/MaqlEditor/maql/monacoConverter.js

@@ -0,0 +1,528 @@
+// (C) 2026 GoodData Corporation
+import { Command, CompletionItemKind, CompletionItemLabelDetails, InsertReplaceEdit, InsertTextFormat, MarkupContent, MarkupKind, Range, } from "vscode-languageserver-types";
+function isProtocolCompletionItem(item) {
+    return typeof item === "object" && item !== null && "data" in item;
+}
+function isRangeReplace(value) {
+    return value.insert !== undefined;
+}
+function isString(value) {
+    return typeof value === "string" || value instanceof String;
+}
+function isNumber(value) {
+    return typeof value === "number" || value instanceof Number;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every(isString);
+}
+/**
+ * Converts Monaco editor structures to the language server protocol ones.
+ */
+export class MonacoToProtocolConverter {
+    _monaco;
+    constructor(_monaco) {
+        this._monaco = _monaco;
+    }
+    asPosition(lineNumber, column) {
+        const line = lineNumber === undefined || lineNumber === null ? undefined : lineNumber - 1;
+        const character = column === undefined || column === null ? undefined : column - 1;
+        return { line, character };
+    }
+    asRange(range) {
+        if (range === undefined) {
+            return undefined;
+        }
+        if (range === null) {
+            return null;
+        }
+        if (isRangeReplace(range)) {
+            return this.asRange(range.insert);
+        }
+        const start = this.asPosition(range.startLineNumber, range.startColumn);
+        const end = this.asPosition(range.endLineNumber, range.endColumn);
+        return { start, end };
+    }
+    asCompletionItem(item) {
+        const result = { label: item.label };
+        const protocolItem = isProtocolCompletionItem(item) ? item : undefined;
+        if (item.detail) {
+            result.detail = item.detail;
+        }
+        if (item.documentation) {
+            if (typeof item.documentation === "string") {
+                result.documentation = item.documentation;
+            }
+            else {
+                result.documentation = this.asDocumentation(protocolItem?.documentationFormat ?? MarkupKind.Markdown, item.documentation);
+            }
+        }
+        if (item.filterText) {
+            result.filterText = item.filterText;
+        }
+        this.fillPrimaryInsertText(result, item);
+        if (isNumber(item.kind)) {
+            result.kind = this.asCompletionItemKind(item.kind, protocolItem?.originalItemKind);
+        }
+        if (item.sortText) {
+            result.sortText = item.sortText;
+        }
+        if (item.additionalTextEdits) {
+            result.additionalTextEdits = this.asTextEdits(item.additionalTextEdits);
+        }
+        if (item.commitCharacters) {
+            result.commitCharacters = item.commitCharacters.slice();
+        }
+        if (item.command) {
+            result.command = this.asCommand(item.command);
+        }
+        if (item.preselect === true || item.preselect === false) {
+            result.preselect = item.preselect;
+        }
+        if (protocolItem) {
+            if (protocolItem.data !== undefined) {
+                result.data = protocolItem.data;
+            }
+            if (protocolItem.deprecated === true || protocolItem.deprecated === false) {
+                result.deprecated = protocolItem.deprecated;
+            }
+        }
+        if (item.tags) {
+            result.tags = item.tags.slice();
+        }
+        return result;
+    }
+    asFormattingOptions(options) {
+        return { tabSize: options.tabSize, insertSpaces: options.insertSpaces };
+    }
+    asTextEdit(edit) {
+        return {
+            range: this.asRange(edit.range),
+            newText: edit.text || "",
+        };
+    }
+    asTextEdits(items) {
+        if (!items) {
+            return undefined;
+        }
+        return items.map((item) => this.asTextEdit(item));
+    }
+    asCommand(item) {
+        if (item) {
+            const args = item.arguments || [];
+            return Command.create(item.title, item.id, ...args);
+        }
+        return undefined;
+    }
+    asCompletionItemKind(value, original) {
+        if (original !== undefined) {
+            return original;
+        }
+        const kinds = this._monaco.languages.CompletionItemKind;
+        switch (value) {
+            case kinds.Method:
+                return CompletionItemKind.Method;
+            case kinds.Function:
+                return CompletionItemKind.Function;
+            case kinds.Constructor:
+                return CompletionItemKind.Constructor;
+            case kinds.Field:
+                return CompletionItemKind.Field;
+            case kinds.Variable:
+                return CompletionItemKind.Variable;
+            case kinds.Class:
+                return CompletionItemKind.Class;
+            case kinds.Struct:
+                return CompletionItemKind.Struct;
+            case kinds.Interface:
+                return CompletionItemKind.Interface;
+            case kinds.Module:
+                return CompletionItemKind.Module;
+            case kinds.Property:
+                return CompletionItemKind.Property;
+            case kinds.Event:
+                return CompletionItemKind.Event;
+            case kinds.Operator:
+                return CompletionItemKind.Operator;
+            case kinds.Unit:
+                return CompletionItemKind.Unit;
+            case kinds.Value:
+                return CompletionItemKind.Value;
+            case kinds.Constant:
+                return CompletionItemKind.Constant;
+            case kinds.Enum:
+                return CompletionItemKind.Enum;
+            case kinds.EnumMember:
+                return CompletionItemKind.EnumMember;
+            case kinds.Keyword:
+                return CompletionItemKind.Keyword;
+            case kinds.Text:
+                return CompletionItemKind.Text;
+            case kinds.Color:
+                return CompletionItemKind.Color;
+            case kinds.File:
+                return CompletionItemKind.File;
+            case kinds.Reference:
+                return CompletionItemKind.Reference;
+            case kinds.Customcolor:
+                return CompletionItemKind.Color;
+            case kinds.Folder:
+                return CompletionItemKind.Folder;
+            case kinds.TypeParameter:
+                return CompletionItemKind.TypeParameter;
+            case kinds.Snippet:
+                return CompletionItemKind.Snippet;
+            default:
+                return (value + 1);
+        }
+    }
+    asDocumentation(format, documentation) {
+        switch (format) {
+            case MarkupKind.PlainText:
+                return { kind: format, value: documentation };
+            case MarkupKind.Markdown:
+                return { kind: format, value: documentation.value };
+            default:
+                return `Unsupported Markup content received. Kind is: ${format}`;
+        }
+    }
+    fillPrimaryInsertText(target, source) {
+        // insertTextRules is a bit set; the snippet flag is tested with a bitmask, as upstream does.
+        const snippetRule = this._monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+        const hasSnippetRule = source.insertTextRules !== undefined && (source.insertTextRules & snippetRule) !== 0;
+        const format = source.insertTextRules !== undefined && !hasSnippetRule
+            ? InsertTextFormat.Snippet
+            : InsertTextFormat.PlainText;
+        target.insertTextFormat = format;
+        const text = source.insertText;
+        const range = source.range ? this.asRange(source.range) : undefined;
+        if (source.fromEdit && text && range) {
+            target.textEdit = { newText: text, range };
+        }
+        else {
+            target.insertText = text;
+        }
+        target.insertTextMode = source.insertTextMode;
+    }
+}
+/**
+ * Converts language server protocol structures to the Monaco editor ones.
+ */
+export class ProtocolToMonacoConverter {
+    _monaco;
+    constructor(_monaco) {
+        this._monaco = _monaco;
+    }
+    asTextEdit(edit) {
+        return {
+            range: this.asRange(edit.range),
+            text: edit.newText,
+        };
+    }
+    asTextEdits(items) {
+        if (!items) {
+            return undefined;
+        }
+        return items.map((item) => this.asTextEdit(item));
+    }
+    asCommand(command) {
+        if (!command) {
+            return undefined;
+        }
+        return {
+            id: command.command,
+            title: command.title,
+            arguments: command.arguments,
+        };
+    }
+    asHover(hover) {
+        if (!hover) {
+            return undefined;
+        }
+        return {
+            contents: this.asHoverContent(hover.contents),
+            range: this.asRange(hover.range),
+        };
+    }
+    asHoverContent(contents) {
+        if (Array.isArray(contents)) {
+            return contents.map((content) => this.asMarkdownString(content));
+        }
+        return [this.asMarkdownString(contents)];
+    }
+    asDocumentation(value) {
+        if (isString(value)) {
+            return value;
+        }
+        if (value.kind === MarkupKind.PlainText) {
+            return value.value;
+        }
+        return this.asMarkdownString(value);
+    }
+    asMarkdownString(content) {
+        if (MarkupContent.is(content)) {
+            return { value: content.value };
+        }
+        if (isString(content)) {
+            return { value: content };
+        }
+        const { language, value } = content;
+        return { value: "```" + language + "\n" + value + "\n```" };
+    }
+    asSeverity(severity) {
+        if (severity === 1) {
+            return this._monaco.MarkerSeverity.Error;
+        }
+        if (severity === 2) {
+            return this._monaco.MarkerSeverity.Warning;
+        }
+        if (severity === 3) {
+            return this._monaco.MarkerSeverity.Info;
+        }
+        return this._monaco.MarkerSeverity.Hint;
+    }
+    asDiagnostics(diagnostics) {
+        if (!diagnostics) {
+            return undefined;
+        }
+        return diagnostics.map((diagnostic) => this.asDiagnostic(diagnostic));
+    }
+    asDiagnostic(diagnostic) {
+        return {
+            code: typeof diagnostic.code === "number" ? diagnostic.code.toString() : diagnostic.code,
+            severity: this.asSeverity(diagnostic.severity),
+            message: diagnostic.message,
+            source: diagnostic.source,
+            startLineNumber: diagnostic.range.start.line + 1,
+            startColumn: diagnostic.range.start.character + 1,
+            endLineNumber: diagnostic.range.end.line + 1,
+            endColumn: diagnostic.range.end.character + 1,
+            relatedInformation: this.asRelatedInformations(diagnostic.relatedInformation),
+            tags: diagnostic.tags,
+        };
+    }
+    asRelatedInformations(relatedInformation) {
+        if (!relatedInformation) {
+            return undefined;
+        }
+        return relatedInformation.map((item) => this.asRelatedInformation(item));
+    }
+    asRelatedInformation(relatedInformation) {
+        return {
+            resource: this._monaco.Uri.parse(relatedInformation.location.uri),
+            startLineNumber: relatedInformation.location.range.start.line + 1,
+            startColumn: relatedInformation.location.range.start.character + 1,
+            endLineNumber: relatedInformation.location.range.end.line + 1,
+            endColumn: relatedInformation.location.range.end.character + 1,
+            message: relatedInformation.message,
+        };
+    }
+    asCompletionResult(result, defaultMonacoRange) {
+        if (!result) {
+            return { incomplete: false, suggestions: [] };
+        }
+        if (Array.isArray(result)) {
+            return {
+                incomplete: false,
+                suggestions: result.map((item) => this.asCompletionItem(item, defaultMonacoRange)),
+            };
+        }
+        const defaultRange = this.getCompletionItemDefaultRange(result);
+        return {
+            incomplete: result.isIncomplete,
+            suggestions: result.items.map((item) => this.asCompletionItem(item, defaultMonacoRange, defaultRange, result.itemDefaults)),
+        };
+    }
+    asCompletionItem(item, defaultMonacoRange, defaultRange, itemDefaults) {
+        const result = { label: this.asCompletionItemLabel(item) };
+        if (item.detail) {
+            result.detail = item.detail;
+        }
+        if (item.documentation) {
+            result.documentation = this.asDocumentation(item.documentation);
+            result.documentationFormat = isString(item.documentation) ? undefined : item.documentation.kind;
+        }
+        if (item.filterText) {
+            result.filterText = item.filterText;
+        }
+        const insertText = this.asCompletionInsertText(item, defaultRange, itemDefaults?.insertTextFormat);
+        result.insertText = insertText.insertText;
+        result.range = insertText.range ?? defaultMonacoRange;
+        result.fromEdit = insertText.fromEdit;
+        if (insertText.isSnippet) {
+            result.insertTextRules = this._monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+        }
+        if (isNumber(item.kind)) {
+            const [itemKind, original] = this.asCompletionItemKind(item.kind);
+            result.kind = itemKind;
+            if (original) {
+                result.originalItemKind = original;
+            }
+        }
+        if (item.sortText) {
+            result.sortText = item.sortText;
+        }
+        if (item.additionalTextEdits) {
+            result.additionalTextEdits = this.asTextEdits(item.additionalTextEdits);
+        }
+        if (isStringArray(item.commitCharacters)) {
+            result.commitCharacters = item.commitCharacters.slice();
+        }
+        if (item.command) {
+            result.command = this.asCommand(item.command);
+        }
+        if (item.deprecated === true || item.deprecated === false) {
+            result.deprecated = item.deprecated;
+        }
+        if (item.preselect === true || item.preselect === false) {
+            result.preselect = item.preselect;
+        }
+        const data = item.data ?? itemDefaults?.data;
+        if (data !== undefined) {
+            result.data = data;
+        }
+        const insertTextMode = item.insertTextMode ?? itemDefaults?.insertTextMode;
+        if (insertTextMode) {
+            result.insertTextMode = insertTextMode;
+        }
+        if (item.tags) {
+            result.tags = item.tags;
+        }
+        return result;
+    }
+    getCompletionItemDefaultRange(list) {
+        const rangeDefaults = list.itemDefaults?.editRange;
+        if (Range.is(rangeDefaults)) {
+            return this.asRange(rangeDefaults);
+        }
+        return rangeDefaults === undefined
+            ? undefined
+            : { insert: this.asRange(rangeDefaults.insert), replace: this.asRange(rangeDefaults.replace) };
+    }
+    asCompletionItemLabel(item) {
+        if (CompletionItemLabelDetails.is(item.labelDetails)) {
+            return {
+                label: item.label,
+                detail: item.labelDetails.detail,
+                description: item.labelDetails.description,
+            };
+        }
+        return item.label;
+    }
+    asCompletionItemKind(value) {
+        const kinds = this._monaco.languages.CompletionItemKind;
+        if (CompletionItemKind.Text <= value && value <= CompletionItemKind.TypeParameter) {
+            switch (value) {
+                case CompletionItemKind.Text:
+                    return [kinds.Text, undefined];
+                case CompletionItemKind.Method:
+                    return [kinds.Method, undefined];
+                case CompletionItemKind.Function:
+                    return [kinds.Function, undefined];
+                case CompletionItemKind.Constructor:
+                    return [kinds.Constructor, undefined];
+                case CompletionItemKind.Field:
+                    return [kinds.Field, undefined];
+                case CompletionItemKind.Variable:
+                    return [kinds.Variable, undefined];
+                case CompletionItemKind.Class:
+                    return [kinds.Class, undefined];
+                case CompletionItemKind.Interface:
+                    return [kinds.Interface, undefined];
+                case CompletionItemKind.Module:
+                    return [kinds.Module, undefined];
+                case CompletionItemKind.Property:
+                    return [kinds.Property, undefined];
+                case CompletionItemKind.Unit:
+                    return [kinds.Unit, undefined];
+                case CompletionItemKind.Value:
+                    return [kinds.Value, undefined];
+                case CompletionItemKind.Enum:
+                    return [kinds.Enum, undefined];
+                case CompletionItemKind.Keyword:
+                    return [kinds.Keyword, undefined];
+                case CompletionItemKind.Snippet:
+                    return [kinds.Snippet, undefined];
+                case CompletionItemKind.Color:
+                    return [kinds.Color, undefined];
+                case CompletionItemKind.File:
+                    return [kinds.File, undefined];
+                case CompletionItemKind.Reference:
+                    return [kinds.Reference, undefined];
+                case CompletionItemKind.Folder:
+                    return [kinds.Folder, undefined];
+                case CompletionItemKind.EnumMember:
+                    return [kinds.EnumMember, undefined];
+                case CompletionItemKind.Constant:
+                    return [kinds.Constant, undefined];
+                case CompletionItemKind.Struct:
+                    return [kinds.Struct, undefined];
+                case CompletionItemKind.Event:
+                    return [kinds.Event, undefined];
+                case CompletionItemKind.Operator:
+                    return [kinds.Operator, undefined];
+                case CompletionItemKind.TypeParameter:
+                    return [kinds.TypeParameter, undefined];
+                default:
+                    return [value - 1, undefined];
+            }
+        }
+        return [CompletionItemKind.Text, value];
+    }
+    asCompletionInsertText(item, defaultRange, defaultInsertTextFormat) {
+        const insertTextFormat = item.insertTextFormat ?? defaultInsertTextFormat;
+        const isSnippet = insertTextFormat === InsertTextFormat.Snippet;
+        if (item.textEdit !== undefined || defaultRange !== undefined) {
+            const [range, newText] = item.textEdit === undefined
+                ? [defaultRange, item.textEditText ?? item.label]
+                : this.getCompletionRangeAndText(item.textEdit);
+            return { insertText: newText, range, fromEdit: true, isSnippet };
+        }
+        if (item.insertText) {
+            return { isSnippet, insertText: item.insertText, fromEdit: false, range: defaultRange };
+        }
+        return { insertText: item.label, range: defaultRange, fromEdit: false, isSnippet: false };
+    }
+    getCompletionRangeAndText(value) {
+        if (InsertReplaceEdit.is(value)) {
+            return [
+                { insert: this.asRange(value.insert), replace: this.asRange(value.replace) },
+                value.newText,
+            ];
+        }
+        return [this.asRange(value.range), value.newText];
+    }
+    asRange(range) {
+        if (range === undefined) {
+            return undefined;
+        }
+        if (range === null) {
+            return null;
+        }
+        const start = this.asPosition(range.start);
+        const end = this.asPosition(range.end);
+        if (start instanceof this._monaco.Position && end instanceof this._monaco.Position) {
+            return new this._monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
+        }
+        return {
+            startLineNumber: start?.lineNumber,
+            startColumn: start?.column,
+            endLineNumber: end?.lineNumber,
+            endColumn: end?.column,
+        };
+    }
+    asPosition(position) {
+        if (position === undefined) {
+            return undefined;
+        }
+        if (position === null) {
+            return null;
+        }
+        const { line, character } = position;
+        const lineNumber = line === undefined ? undefined : line + 1;
+        const column = character === undefined ? undefined : character + 1;
+        if (lineNumber !== undefined && column !== undefined) {
+            return new this._monaco.Position(lineNumber, column);
+        }
+        return { lineNumber, column };
+    }
+}

package/esm/translations/de-DE.json

@@ -117,13 +117,6 @@
     "metricComponent.minimize.editing": "Bearbeitung:",
     "metricComponent.minimize.viewing": "In Betrachtung",
     "metricComponent.minimize.metrics": "{edited, plural, one {# Metrik} other {# Metriken}}",
-    "messages.genAi.visualisation.saved.success": "Großartig! Wir haben Ihre Visualisierung gespeichert.",
-    "messages.genAi.visualisation.saved.error": "Hoppla, beim Speichern Ihrer Visualisierung ist ein Problem aufgetreten.",
-    "messages.genAi.visualisation.saved.error.detail": "{errorType}: {errorMessage}",
-    "messages.genAi.visualisation.link.copied": "Der Visualisierungslink wurde in Ihre Zwischenablage kopiert.",
-    "gen-ai.ask-assistant.search": "Erstellen Sie eine neue Visualisierung basierend auf: {question}",
-    "gd.gen-ai.feedback.success": "<b>Erfolg.</b> Wir haben Ihr Feedback erhalten und werden es nutzen, um die Erfahrung zu verbessern.",
-    "gd.gen-ai.feedback.error": "<b>Fehler.</b> Wir konnten Ihr Feedback nicht senden – versuchen Sie es später erneut.",
     "metricComponent.tags.manager.label.more": "Weitere Tags",
     "metricComponent.tags.manager.label.noTags": "Keine Tags",
     "metricComponent.tags.manager.label.close": "Schließen",
@@ -132,54 +125,7 @@
     "metricComponent.tags.manager.label.cancelLabel": "Abbrechen",
     "metricComponent.tags.manager.label.saveLabel": "Speichern",
     "metricComponent.tags.manager.label.removeLabel": "Entfernen",
-    "gs.header.helpMenu.creating.metrics": "Metriken erstellen",
-    "gs.header.helpMenu.starting.MAQL": "Erste Schritte mit MAQL",
-    "gs.header.helpMenu.writing.MAQL": "Erweiterte MAQL-Abfragen schreiben",
-    "documentHeader.pageTitle": "Metriken",
-    "error.notFound.title": "Wir können diese Seite nicht finden",
-    "error.notFound.description": "Sie wurde möglicherweise gelöscht oder Sie haben keinen Zugriff.",
-    "error.metricNotFound.title": "Wir können diese Metrik nicht finden",
-    "error.metricNotFound.description": "Sie wurde möglicherweise gelöscht oder Sie haben keinen Zugriff.",
-    "error.unknown.title": "UNBEKANNTER FEHLER",
-    "error.unknown.description": "Wir sind uns nicht ganz sicher, was hier schiefgelaufen ist. Bitte später erneut versuchen.",
-    "error.redirect.workspace": "Zurück zur Liste der Metriken",
-    "communityEdition.badge.text": "Community Edition",
-    "communityEdition.dialog.header": "Infos zur GoodData.CN Community Edition",
-    "communityEdition.dialog.info": "Die Community Edition dient nur zu Bewertungszwecken.",
-    "communityEdition.dialog.copyright": "Copyright (c) {year} GoodData Corporation.",
-    "communityEdition.dialog.link.license": "Lizenz",
-    "communityEdition.dialog.link.attribution": "OSS Attribution file",
-    "communityEdition.dialog.link.privacy": "Datenschutzrichtlinien",
-    "communityEdition.dialog.button.close": "Schließen",
-    "metricList.header.title": "Name",
-    "metricList.header.id": "ID",
-    "metricList.itemDropdown.edit": "Bearbeiten",
-    "metricList.itemDropdown.makeCopy": "Kopie erstellen",
-    "metricList.itemDropdown.delete": "Löschen",
-    "metricList.metricListItem.protected_report": "Sie können diese Metrik weder bearbeiten noch löschen, da sie im übergeordneten Workspace erstellt wurde. Um die Metrik zu bearbeiten oder zu löschen, gehen Sie bitte zum übergeordneten Workspace.",
     "metricList.metricListItemTooltip.defined": "definiert als",
-    "metricList.emptyState.title": "Wiederverwendbare Berechnungen definieren",
-    "metricList.emptyState.description": "Metriken ermöglichen es Ihnen, Berechnungen auf Grundlage Ihrer Daten zu definieren. Es ist eine großartige Möglichkeit, Geschäftslogik für alle Benutzer zu standardisieren.{br}{br}Sobald eine Metrik erstellt wurde, können Sie sie verwenden, um Visualisierungen oder komplexere Berechnungen zu erstellen.",
-    "metricList.emptyState.createMetric": "Metrik erstellen",
-    "metricList.emptyState.forbiddenCreate": "Sie sind nicht berechtigt, Metriken in diesem Workspace zu erstellen.",
-    "metricList.emptyState.documentationLink": "Wie erstelle ich Metriken",
-    "metricList.messages.metricSaved": "Großartig! Wir haben Ihre Metrik gespeichert.",
-    "metricList.messages.metricSaveFailed": "Speicherfehler.",
-    "metricList.messages.metricSaveFailedEmptyExpression": "Die Metrik kann nicht mit einem leeren Ausdruck gespeichert werden",
-    "metricList.messages.metricDeleted": "Großartig! Wir haben Ihre Metrik gelöscht.",
-    "metricList.messages.metricDeleteFailed": "Löschfehler.",
-    "metricList.metricListTopBar.headline": "Metriken",
-    "metricList.metricListTopBar.create": "Metrik erstellen",
-    "metricList.search.placeholder": "Name oder ID suchen",
-    "metricList.emptySearchResult": "Keine passende Metrik für „{search}“",
-    "metricList.noMetrics": "Keine Metriken",
     "metricList.tooltip.deleted_value": "gelöschtes Attribut",
-    "metricList.tooltip.empty_value": "leerer Wert",
-    "contractExpiredDialog.buttonTitle": "Kontakt",
-    "contractExpiredDialog.trial.title": "Ihre Testversion ist abgelaufen!",
-    "contractExpiredDialog.trial.description": "Wenn Sie GoodData Cloud weiterhin nutzen möchten, kontaktieren Sie uns bitte.",
-    "contractExpiredDialog.nonTrial.title": "Ihr Zugriff ist gesperrt!",
-    "contractExpiredDialog.nonTrial.description": "Wenden Sie sich an den Kontoadministrator, um wieder Zugriff zu erhalten.",
-    "messages.showMore": "Mehr anzeigen",
-    "messages.showLess": "Weniger anzeigen"
+    "metricList.tooltip.empty_value": "leerer Wert"
 }

package/esm/translations/en-AU.json

@@ -117,13 +117,6 @@
     "metricComponent.minimize.editing": "Editing:",
     "metricComponent.minimize.viewing": "Viewing",
     "metricComponent.minimize.metrics": "{edited, plural, one {# metric} other {# metrics}}",
-    "messages.genAi.visualisation.saved.success": "Great! We've saved your visualisation.",
-    "messages.genAi.visualisation.saved.error": "Unfortunately, there was an issue when saving your visualisation.",
-    "messages.genAi.visualisation.saved.error.detail": "{errorType}: {errorMessage}",
-    "messages.genAi.visualisation.link.copied": "The visualisation link has been copied to your clipboard.",
-    "gen-ai.ask-assistant.search": "Create new visualisation based on: {question}",
-    "gd.gen-ai.feedback.success": "<b>Success</b> We’ve received your feedback and will use it to enhance the experience",
-    "gd.gen-ai.feedback.error": "<b>Error.</b> We couldn't send your feedback — please try again later.",
     "metricComponent.tags.manager.label.more": "More tags",
     "metricComponent.tags.manager.label.noTags": "No tags",
     "metricComponent.tags.manager.label.close": "Close",
@@ -132,54 +125,7 @@
     "metricComponent.tags.manager.label.cancelLabel": "Cancel",
     "metricComponent.tags.manager.label.saveLabel": "Save",
     "metricComponent.tags.manager.label.removeLabel": "Remove",
-    "gs.header.helpMenu.creating.metrics": "Creating metrics",
-    "gs.header.helpMenu.starting.MAQL": "Getting started with MAQL",
-    "gs.header.helpMenu.writing.MAQL": "Writing advanced MAQL queries",
-    "documentHeader.pageTitle": "Metrics",
-    "error.notFound.title": "We can't find this page",
-    "error.notFound.description": "It may have been deleted or you don't have access.",
-    "error.metricNotFound.title": "We can't find this metric",
-    "error.metricNotFound.description": "It may have been deleted or you don't have access.",
-    "error.unknown.title": "UNKNOWN ERROR",
-    "error.unknown.description": "We’re not quite sure what went wrong. Please try again later.",
-    "error.redirect.workspace": "Back to metrics list",
-    "communityEdition.badge.text": "Community Edition",
-    "communityEdition.dialog.header": "About GoodData.CN Community Edition",
-    "communityEdition.dialog.info": "The Community Edition is meant for evaluation purposes only.",
-    "communityEdition.dialog.copyright": "Copyright (c) {year} GoodData Corporation.",
-    "communityEdition.dialog.link.license": "License",
-    "communityEdition.dialog.link.attribution": "OSS Attribution file",
-    "communityEdition.dialog.link.privacy": "Privacy policy",
-    "communityEdition.dialog.button.close": "Close",
-    "metricList.header.title": "Name",
-    "metricList.header.id": "ID",
-    "metricList.itemDropdown.edit": "Edit",
-    "metricList.itemDropdown.makeCopy": "Make a copy",
-    "metricList.itemDropdown.delete": "Delete",
-    "metricList.metricListItem.protected_report": "You cannot edit or delete this metric because it was created in the parent workspace. To edit or delete the metric, do so from the parent workspace.",
     "metricList.metricListItemTooltip.defined": "defined as",
-    "metricList.emptyState.title": "Define reusable calculations",
-    "metricList.emptyState.description": "Metrics allow you to define calculations on top of your data. It's a great method to standardise business logic for all users.{br}{br}Once a metric is created, you can then use it to create visualisations or more complex calculations.",
-    "metricList.emptyState.createMetric": "Create metric",
-    "metricList.emptyState.forbiddenCreate": "You do not have permission to create metrics in this workspace.",
-    "metricList.emptyState.documentationLink": "How to create metrics",
-    "metricList.messages.metricSaved": "Great! We've saved your metric.",
-    "metricList.messages.metricSaveFailed": "Save error.",
-    "metricList.messages.metricSaveFailedEmptyExpression": "Metric cannot be saved with an empty expression",
-    "metricList.messages.metricDeleted": "Great! We've deleted your metric.",
-    "metricList.messages.metricDeleteFailed": "Delete error.",
-    "metricList.metricListTopBar.headline": "Metrics",
-    "metricList.metricListTopBar.create": "Create metric",
-    "metricList.search.placeholder": "Search for name or ID",
-    "metricList.emptySearchResult": "No metric matching ''{search}''",
-    "metricList.noMetrics": "No metrics",
     "metricList.tooltip.deleted_value": "deleted attribute",
-    "metricList.tooltip.empty_value": "empty value",
-    "contractExpiredDialog.buttonTitle": "Contact us",
-    "contractExpiredDialog.trial.title": "Your trial period has expired",
-    "contractExpiredDialog.trial.description": "Contact us if you would like to continue using GoodData Cloud.",
-    "contractExpiredDialog.nonTrial.title": "Your access is restricted",
-    "contractExpiredDialog.nonTrial.description": "Contact the account administrator to regain access.",
-    "messages.showMore": "Show more",
-    "messages.showLess": "Show less"
+    "metricList.tooltip.empty_value": "empty value"
 }