{"version":3,"file":"loki-query-field.js","mappings":"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","sources":["webpack://loki/../../../../../node_modules/react-use/esm/useLatest.js","webpack://loki/./components/monaco-query-field/getOverrideServices.ts","webpack://loki/./components/monaco-query-field/monaco-completion-provider/CompletionDataProvider.ts","webpack://loki/./components/monaco-query-field/monaco-completion-provider/NeverCaseError.ts","webpack://loki/./components/monaco-query-field/monaco-completion-provider/completions.ts","webpack://loki/./components/monaco-query-field/monaco-completion-provider/situation.ts","webpack://loki/./components/monaco-query-field/monaco-completion-provider/completionUtils.ts","webpack://loki/./components/monaco-query-field/MonacoQueryField.tsx","webpack://loki/../../../../../node_modules/@grafana/monaco-logql/index.js"],"sourcesContent":["import { useRef } from 'react';\nvar useLatest = function (value) {\n var ref = useRef(value);\n ref.current = value;\n return ref;\n};\nexport default useLatest;\n","import { monacoTypes } from '@grafana/ui';\n\n// this thing here is a workaround in a way.\n// what we want to achieve, is that when the autocomplete-window\n// opens, the \"second, extra popup\" with the extra help,\n// also opens automatically.\n// but there is no API to achieve it.\n// the way to do it is to implement the `storageService`\n// interface, and provide our custom implementation,\n// which will default to `true` for the correct string-key.\n// unfortunately, while the typescript-interface exists,\n// it is not exported from monaco-editor,\n// so we cannot rely on typescript to make sure\n// we do it right. all we can do is to manually\n// lookup the interface, and make sure we code our code right.\n// our code is a \"best effort\" approach,\n// i am not 100% how the `scope` and `target` things work,\n// but so far it seems to work ok.\n// i would use an another approach, if there was one available.\n\nfunction makeStorageService() {\n // we need to return an object that fulfills this interface:\n // https://github.com/microsoft/vscode/blob/ff1e16eebb93af79fd6d7af1356c4003a120c563/src/vs/platform/storage/common/storage.ts#L37\n // unfortunately it is not export from monaco-editor\n\n const strings = new Map<string, string>();\n\n // we want this to be true by default\n strings.set('expandSuggestionDocs', true.toString());\n\n return {\n // we do not implement the on* handlers\n onDidChangeValue: (data: unknown): void => undefined,\n onDidChangeTarget: (data: unknown): void => undefined,\n onWillSaveState: (data: unknown): void => undefined,\n\n get: (key: string, scope: unknown, fallbackValue?: string): string | undefined => {\n return strings.get(key) ?? fallbackValue;\n },\n\n getBoolean: (key: string, scope: unknown, fallbackValue?: boolean): boolean | undefined => {\n const val = strings.get(key);\n if (val !== undefined) {\n // the interface docs say the value will be converted\n // to a boolean but do not specify how, so we improvise\n return val === 'true';\n } else {\n return fallbackValue;\n }\n },\n\n getNumber: (key: string, scope: unknown, fallbackValue?: number): number | undefined => {\n const val = strings.get(key);\n if (val !== undefined) {\n return parseInt(val, 10);\n } else {\n return fallbackValue;\n }\n },\n\n store: (\n key: string,\n value: string | boolean | number | undefined | null,\n scope: unknown,\n target: unknown\n ): void => {\n // the interface docs say if the value is nullish, it should act as delete\n if (value === null || value === undefined) {\n strings.delete(key);\n } else {\n strings.set(key, value.toString());\n }\n },\n\n remove: (key: string, scope: unknown): void => {\n strings.delete(key);\n },\n\n keys: (scope: unknown, target: unknown): string[] => {\n return Array.from(strings.keys());\n },\n\n logStorage: (): void => {\n console.log('logStorage: not implemented');\n },\n\n migrate: (): Promise<void> => {\n // we do not implement this\n return Promise.resolve(undefined);\n },\n\n isNew: (scope: unknown): boolean => {\n // we create a new storage for every session, we do not persist it,\n // so we return `true`.\n return true;\n },\n\n flush: (reason?: unknown): Promise<void> => {\n // we do not implement this\n return Promise.resolve(undefined);\n },\n };\n}\n\nlet overrideServices: monacoTypes.editor.IEditorOverrideServices = {\n storageService: makeStorageService(),\n};\n\nexport function getOverrideServices(): monacoTypes.editor.IEditorOverrideServices {\n // One instance of this for every query editor\n return overrideServices;\n}\n","import { chain } from 'lodash';\n\nimport { HistoryItem, TimeRange } from '@grafana/data';\n\nimport LanguageProvider from '../../../LanguageProvider';\nimport { escapeLabelValueInExactSelector } from '../../../languageUtils';\nimport { ParserAndLabelKeysResult, LokiQuery } from '../../../types';\n\nimport { Label } from './situation';\n\ninterface HistoryRef {\n current: Array<HistoryItem<LokiQuery>>;\n}\n\nexport class CompletionDataProvider {\n constructor(\n private languageProvider: LanguageProvider,\n private historyRef: HistoryRef = { current: [] },\n private timeRange: TimeRange | undefined\n ) {\n this.queryToLabelKeysCache = new Map();\n }\n private queryToLabelKeysCache: Map<string, ParserAndLabelKeysResult>;\n\n private buildSelector(labels: Label[]): string {\n const allLabelTexts = labels.map(\n (label) => `${label.name}${label.op}\"${escapeLabelValueInExactSelector(label.value)}\"`\n );\n\n return `{${allLabelTexts.join(',')}}`;\n }\n\n setTimeRange(timeRange: TimeRange) {\n this.timeRange = timeRange;\n this.queryToLabelKeysCache.clear();\n }\n\n getHistory() {\n return chain(this.historyRef.current)\n .orderBy('ts', 'desc')\n .map((history: HistoryItem<LokiQuery>) => history.query.expr.trim())\n .filter()\n .uniq()\n .value();\n }\n\n async getLabelNames(otherLabels: Label[] = []) {\n if (otherLabels.length === 0) {\n // If there is no filtering, we use getLabelKeys because it has better caching\n // and all labels should already be fetched\n await this.languageProvider.start(this.timeRange);\n return this.languageProvider.getLabelKeys();\n }\n const possibleLabelNames = await this.languageProvider.fetchLabels({\n streamSelector: this.buildSelector(otherLabels),\n timeRange: this.timeRange,\n });\n const usedLabelNames = new Set(otherLabels.map((l) => l.name)); // names used in the query\n return possibleLabelNames.filter((label) => !usedLabelNames.has(label));\n }\n\n async getLabelValues(labelName: string, otherLabels: Label[]) {\n return await this.languageProvider.fetchLabelValues(labelName, {\n streamSelector: this.buildSelector(otherLabels),\n timeRange: this.timeRange,\n });\n }\n\n /**\n * Runs a Loki query to extract label keys from the result.\n * The result is cached for the query string.\n *\n * Since various \"situations\" in the monaco code editor trigger this function, it is prone to being called multiple times for the same query\n * Here is a lightweight and simple cache to avoid calling the backend multiple times for the same query.\n *\n * @param logQuery\n */\n async getParserAndLabelKeys(logQuery: string): Promise<ParserAndLabelKeysResult> {\n const EXTRACTED_LABEL_KEYS_MAX_CACHE_SIZE = 2;\n const cachedLabelKeys = this.queryToLabelKeysCache.has(logQuery) ? this.queryToLabelKeysCache.get(logQuery) : null;\n if (cachedLabelKeys) {\n // cache hit! Serve stale result from cache\n return cachedLabelKeys;\n } else {\n // If cache is larger than max size, delete the first (oldest) index\n if (this.queryToLabelKeysCache.size >= EXTRACTED_LABEL_KEYS_MAX_CACHE_SIZE) {\n // Make room in the cache for the fresh result by deleting the \"first\" index\n const keys = this.queryToLabelKeysCache.keys();\n const firstKey = keys.next().value;\n if (firstKey !== undefined) {\n this.queryToLabelKeysCache.delete(firstKey);\n }\n }\n // Fetch a fresh result from the backend\n const labelKeys = await this.languageProvider.getParserAndLabelKeys(logQuery, { timeRange: this.timeRange });\n // Add the result to the cache\n this.queryToLabelKeysCache.set(logQuery, labelKeys);\n return labelKeys;\n }\n }\n}\n","// This helper class is used to make typescript warn you when you miss a case-block in a switch statement.\n// For example:\n//\n// const x:'A'|'B'|'C' = 'A';\n//\n// switch(x) {\n// case 'A':\n// // something\n// case 'B':\n// // something\n// default:\n// throw new NeverCaseError(x);\n// }\n//\n//\n// TypeScript detect the missing case and display an error.\n\nexport class NeverCaseError extends Error {\n constructor(value: never) {\n super(`Unexpected case in switch statement: ${JSON.stringify(value)}`);\n }\n}\n","import { trimEnd } from 'lodash';\n\nimport { escapeLabelValueInExactSelector } from '../../../languageUtils';\nimport { isQueryWithParser } from '../../../queryUtils';\nimport { explainOperator } from '../../../querybuilder/operations';\nimport { LokiOperationId } from '../../../querybuilder/types';\nimport { AGGREGATION_OPERATORS, RANGE_VEC_FUNCTIONS, BUILT_IN_FUNCTIONS } from '../../../syntax';\n\nimport { CompletionDataProvider } from './CompletionDataProvider';\nimport { NeverCaseError } from './NeverCaseError';\nimport type { Situation, Label } from './situation';\n\nexport type CompletionType =\n | 'HISTORY'\n | 'FUNCTION'\n | 'DURATION'\n | 'LABEL_NAME'\n | 'LABEL_VALUE'\n | 'PATTERN'\n | 'PARSER'\n | 'LINE_FILTER'\n | 'PIPE_OPERATION';\n\ntype Completion = {\n type: CompletionType;\n label: string;\n insertText: string;\n detail?: string;\n documentation?: string;\n triggerOnInsert?: boolean;\n isSnippet?: boolean;\n};\n\nconst LOG_COMPLETIONS: Completion[] = [\n {\n type: 'PATTERN',\n label: '{}',\n insertText: '{$0}',\n isSnippet: true,\n triggerOnInsert: true,\n },\n];\n\nconst AGGREGATION_COMPLETIONS: Completion[] = AGGREGATION_OPERATORS.map((f) => ({\n type: 'FUNCTION',\n label: f.label,\n insertText: `${f.insertText ?? ''}($0)`, // i don't know what to do when this is nullish. it should not be.\n isSnippet: true,\n triggerOnInsert: true,\n detail: f.detail,\n documentation: f.documentation,\n}));\n\nconst FUNCTION_COMPLETIONS: Completion[] = RANGE_VEC_FUNCTIONS.map((f) => ({\n type: 'FUNCTION',\n label: f.label,\n insertText: `${f.insertText ?? ''}({$0}[\\\\$__auto])`, // i don't know what to do when this is nullish. it should not be.\n isSnippet: true,\n triggerOnInsert: true,\n detail: f.detail,\n documentation: f.documentation,\n}));\n\nconst BUILT_IN_FUNCTIONS_COMPLETIONS: Completion[] = BUILT_IN_FUNCTIONS.map((f) => ({\n type: 'FUNCTION',\n label: f.label,\n insertText: `${f.insertText ?? ''}($0)`,\n isSnippet: true,\n triggerOnInsert: true,\n detail: f.detail,\n documentation: f.documentation,\n}));\n\nconst DURATION_COMPLETIONS: Completion[] = ['$__auto', '1m', '5m', '10m', '30m', '1h', '1d'].map((text) => ({\n type: 'DURATION',\n label: text,\n insertText: text,\n}));\n\nconst UNWRAP_FUNCTION_COMPLETIONS: Completion[] = [\n {\n type: 'FUNCTION',\n label: 'duration_seconds',\n documentation: 'Will convert the label value in seconds from the go duration format (e.g 5m, 24s30ms).',\n insertText: 'duration_seconds()',\n },\n {\n type: 'FUNCTION',\n label: 'duration',\n documentation: 'Short version of duration_seconds().',\n insertText: 'duration()',\n },\n {\n type: 'FUNCTION',\n label: 'bytes',\n documentation: 'Will convert the label value to raw bytes applying the bytes unit (e.g. 5 MiB, 3k, 1G).',\n insertText: 'bytes()',\n },\n];\n\nconst LOGFMT_ARGUMENT_COMPLETIONS: Completion[] = [\n {\n type: 'FUNCTION',\n label: '--strict',\n documentation:\n 'Strict parsing. The logfmt parser stops scanning the log line and returns early with an error when it encounters any poorly formatted key/value pair.',\n insertText: '--strict',\n },\n {\n type: 'FUNCTION',\n label: '--keep-empty',\n documentation:\n 'Retain standalone keys with empty value. The logfmt parser retains standalone keys (keys without a value) as labels with value set to empty string.',\n insertText: '--keep-empty',\n },\n];\n\nconst LINE_FILTER_COMPLETIONS = [\n {\n operator: '|=',\n documentation: explainOperator(LokiOperationId.LineContains),\n afterPipe: true,\n },\n {\n operator: '!=',\n documentation: explainOperator(LokiOperationId.LineContainsNot),\n },\n {\n operator: '|~',\n documentation: explainOperator(LokiOperationId.LineMatchesRegex),\n afterPipe: true,\n },\n {\n operator: '!~',\n documentation: explainOperator(LokiOperationId.LineMatchesRegexNot),\n },\n];\n\nfunction getLineFilterCompletions(afterPipe: boolean): Completion[] {\n return LINE_FILTER_COMPLETIONS.filter((completion) => !afterPipe || completion.afterPipe).map(\n ({ operator, documentation }) => ({\n type: 'LINE_FILTER',\n label: `${operator} \"\"`,\n insertText: `${afterPipe ? operator.replace('|', '') : operator} \"$0\"`,\n isSnippet: true,\n documentation,\n })\n );\n}\n\nfunction getPipeOperationsCompletions(prefix = ''): Completion[] {\n const completions: Completion[] = [];\n completions.push({\n type: 'PIPE_OPERATION',\n label: 'line_format',\n insertText: `${prefix}line_format \"{{.$0}}\"`,\n isSnippet: true,\n documentation: explainOperator(LokiOperationId.LineFormat),\n });\n\n completions.push({\n type: 'PIPE_OPERATION',\n label: 'label_format',\n insertText: `${prefix}label_format`,\n isSnippet: true,\n documentation: explainOperator(LokiOperationId.LabelFormat),\n });\n\n completions.push({\n type: 'PIPE_OPERATION',\n label: 'unwrap',\n insertText: `${prefix}unwrap`,\n documentation: explainOperator(LokiOperationId.Unwrap),\n });\n\n completions.push({\n type: 'PIPE_OPERATION',\n label: 'decolorize',\n insertText: `${prefix}decolorize`,\n documentation: explainOperator(LokiOperationId.Decolorize),\n });\n\n completions.push({\n type: 'PIPE_OPERATION',\n label: 'drop',\n insertText: `${prefix}drop`,\n documentation: explainOperator(LokiOperationId.Drop),\n });\n\n completions.push({\n type: 'PIPE_OPERATION',\n label: 'keep',\n insertText: `${prefix}keep`,\n documentation: explainOperator(LokiOperationId.Keep),\n });\n\n return completions;\n}\n\nasync function getAllHistoryCompletions(dataProvider: CompletionDataProvider): Promise<Completion[]> {\n const history = await dataProvider.getHistory();\n\n return history.map((expr) => ({\n type: 'HISTORY',\n label: expr,\n insertText: expr,\n }));\n}\n\nasync function getLabelNamesForSelectorCompletions(\n otherLabels: Label[],\n dataProvider: CompletionDataProvider\n): Promise<Completion[]> {\n const labelNames = await dataProvider.getLabelNames(otherLabels);\n\n return labelNames.map((label) => ({\n type: 'LABEL_NAME',\n label,\n insertText: `${label}=`,\n triggerOnInsert: true,\n }));\n}\n\nasync function getInGroupingCompletions(logQuery: string, dataProvider: CompletionDataProvider): Promise<Completion[]> {\n const { extractedLabelKeys } = await dataProvider.getParserAndLabelKeys(logQuery);\n\n return extractedLabelKeys.map((label) => ({\n type: 'LABEL_NAME',\n label,\n insertText: label,\n triggerOnInsert: false,\n }));\n}\n\nconst PARSERS = ['json', 'logfmt', 'pattern', 'regexp', 'unpack'];\n\nasync function getParserCompletions(\n prefix: string,\n hasJSON: boolean,\n hasLogfmt: boolean,\n hasPack: boolean,\n extractedLabelKeys: string[],\n hasParserInQuery: boolean\n) {\n const allParsers = new Set(PARSERS);\n const completions: Completion[] = [];\n // We use this to improve documentation specifically for level label as it is tied to showing color-coded logs volume\n const hasLevelInExtractedLabels = extractedLabelKeys.some((key) => key === 'level');\n\n if (hasJSON) {\n // We show \"detected\" label only if there is no previous parser in the query\n const extra = hasParserInQuery ? '' : ' (detected)';\n if (hasPack) {\n allParsers.delete('unpack');\n completions.push({\n type: 'PARSER',\n label: `unpack${extra}`,\n insertText: `${prefix}unpack`,\n documentation: explainOperator(LokiOperationId.Unpack),\n });\n } else {\n allParsers.delete('json');\n completions.push({\n type: 'PARSER',\n label: `json${extra}`,\n insertText: `${prefix}json`,\n documentation: hasLevelInExtractedLabels\n ? 'Use it to get log-levels in the histogram'\n : explainOperator(LokiOperationId.Json),\n });\n }\n }\n\n if (hasLogfmt) {\n allParsers.delete('logfmt');\n // We show \"detected\" label only if there is no previous parser in the query\n const extra = hasParserInQuery ? '' : ' (detected)';\n completions.push({\n type: 'PARSER',\n label: `logfmt${extra}`,\n insertText: `${prefix}logfmt`,\n documentation: hasLevelInExtractedLabels\n ? 'Get detected levels in the histogram'\n : explainOperator(LokiOperationId.Logfmt),\n });\n }\n\n const remainingParsers = Array.from(allParsers).sort();\n remainingParsers.forEach((parser) => {\n completions.push({\n type: 'PARSER',\n label: parser,\n insertText: `${prefix}${parser}`,\n documentation: explainOperator(parser),\n });\n });\n\n return completions;\n}\n\nexport async function getAfterSelectorCompletions(\n logQuery: string,\n afterPipe: boolean,\n hasSpace: boolean,\n dataProvider: CompletionDataProvider\n): Promise<Completion[]> {\n let query = logQuery;\n if (afterPipe) {\n query = trimEnd(logQuery, '| ');\n }\n\n const { extractedLabelKeys, structuredMetadataKeys, hasJSON, hasLogfmt, hasPack } =\n await dataProvider.getParserAndLabelKeys(query);\n const hasQueryParser = isQueryWithParser(query).queryWithParser;\n\n const prefix = `${hasSpace ? '' : ' '}${afterPipe ? '' : '| '}`;\n\n const parserCompletions = await getParserCompletions(\n prefix,\n hasJSON,\n hasLogfmt,\n hasPack,\n extractedLabelKeys,\n hasQueryParser\n );\n const pipeOperations = getPipeOperationsCompletions(prefix);\n\n const completions = [...parserCompletions, ...pipeOperations];\n\n structuredMetadataKeys.forEach((key) => {\n completions.push({\n type: 'LABEL_NAME',\n label: `${key} (detected)`,\n insertText: `${prefix}${key}`,\n documentation: `\"${key}\" was suggested based on structured metadata attached to your loglines.`,\n });\n });\n\n // Let's show label options only if query has parser\n if (hasQueryParser) {\n extractedLabelKeys.forEach((key) => {\n completions.push({\n type: 'LABEL_NAME',\n label: `${key} (detected)`,\n insertText: `${prefix}${key}`,\n documentation: `\"${key}\" was suggested based on the content of your log lines for the label filter expression.`,\n });\n });\n }\n\n // If we have parser, we don't need to consider line filters\n if (hasQueryParser) {\n return [...completions];\n }\n // With a space between the pipe and the cursor, we omit line filters\n // E.g. `{label=\"value\"} | `\n const lineFilters = afterPipe && hasSpace ? [] : getLineFilterCompletions(afterPipe);\n return [...lineFilters, ...completions];\n}\n\nexport async function getLogfmtCompletions(\n logQuery: string,\n flags: boolean,\n trailingComma: boolean | undefined,\n trailingSpace: boolean | undefined,\n otherLabels: string[],\n dataProvider: CompletionDataProvider\n): Promise<Completion[]> {\n let completions: Completion[] = [];\n\n if (trailingComma) {\n // Remove the trailing comma, otherwise the sample query will fail.\n logQuery = trimEnd(logQuery, ', ');\n }\n const { extractedLabelKeys, hasJSON, hasLogfmt, hasPack } = await dataProvider.getParserAndLabelKeys(logQuery);\n const pipeOperations = getPipeOperationsCompletions('| ');\n\n /**\n * The user is not in the process of writing another label, and has not specified 2 flags.\n * The current grammar doesn't allow us to know which flags were used (by node name), so we consider flags = true\n * when 2 have been used.\n * For example:\n * - {label=\"value\"} | logfmt ^\n * - {label=\"value\"} | logfmt --strict ^\n * - {label=\"value\"} | logfmt --strict --keep-empty ^\n */\n if (!trailingComma && !flags) {\n completions = [...LOGFMT_ARGUMENT_COMPLETIONS];\n }\n\n /**\n * If the user has no trailing comma and has a trailing space it can mean that they finished writing the logfmt\n * part and want to move on, for example, with other parsers or pipe operations.\n * For example:\n * - {label=\"value\"} | logfmt --flag ^\n * - {label=\"value\"} | logfmt label, label2 ^\n */\n if (!trailingComma && trailingSpace) {\n /**\n * Don't offer parsers if there is no label argument: {label=\"value\"} | logfmt ^\n * The reason is that it would be unusual that they would want to use another parser just after logfmt, and\n * more likely that they would want a flag, labels, or continue with pipe operations.\n *\n * Offer parsers with at least one label argument: {label=\"value\"} | logfmt label ^\n * The rationale here is to offer the same completions as getAfterSelectorCompletions().\n */\n const parserCompletions =\n otherLabels.length > 0\n ? await getParserCompletions('| ', hasJSON, hasLogfmt, hasPack, extractedLabelKeys, true)\n : [];\n completions = [...completions, ...parserCompletions, ...pipeOperations];\n }\n\n const labels = extractedLabelKeys.filter((label) => !otherLabels.includes(label));\n\n /**\n * We want to decide whether to use a trailing comma or not based on the data we have of the current\n * situation. In particular, the following scenarios will not lead to a trailing comma:\n * {label=\"value\"} | logfmt ^\n * - trailingSpace: true, trailingComma: false, otherLabels: []\n * {label=\"value\"} | logfmt lab^\n * trailingSpace: false, trailignComma: false, otherLabels: [lab]\n * {label=\"value\"} | logfmt label,^\n * trailingSpace: false, trailingComma: true, otherLabels: [label]\n * {label=\"value\"} | logfmt label, ^\n * trailingSpace: true, trailingComma: true, otherLabels: [label]\n */\n let labelPrefix = '';\n if (otherLabels.length > 0 && trailingSpace) {\n labelPrefix = trailingComma ? '' : ', ';\n }\n\n const labelCompletions: Completion[] = labels.map((label) => ({\n type: 'LABEL_NAME',\n label,\n insertText: labelPrefix + label,\n triggerOnInsert: false,\n }));\n\n completions = [...completions, ...labelCompletions];\n\n return completions;\n}\n\nasync function getLabelValuesForMetricCompletions(\n labelName: string,\n betweenQuotes: boolean,\n otherLabels: Label[],\n dataProvider: CompletionDataProvider\n): Promise<Completion[]> {\n const values = await dataProvider.getLabelValues(labelName, otherLabels);\n return values.map((text) => ({\n type: 'LABEL_VALUE',\n label: text,\n insertText: betweenQuotes ? escapeLabelValueInExactSelector(text) : `\"${escapeLabelValueInExactSelector(text)}\"`,\n }));\n}\n\nasync function getAfterUnwrapCompletions(\n logQuery: string,\n dataProvider: CompletionDataProvider\n): Promise<Completion[]> {\n const { unwrapLabelKeys } = await dataProvider.getParserAndLabelKeys(logQuery);\n\n const labelCompletions: Completion[] = unwrapLabelKeys.map((label) => ({\n type: 'LABEL_NAME',\n label,\n insertText: label,\n triggerOnInsert: false,\n }));\n\n return [...labelCompletions, ...UNWRAP_FUNCTION_COMPLETIONS];\n}\n\nasync function getAfterKeepAndDropCompletions(logQuery: string, dataProvider: CompletionDataProvider) {\n const { extractedLabelKeys } = await dataProvider.getParserAndLabelKeys(logQuery);\n const labelCompletions: Completion[] = extractedLabelKeys.map((label) => ({\n type: 'LABEL_NAME',\n label,\n insertText: label,\n triggerOnInsert: false,\n }));\n\n return [...labelCompletions];\n}\n\nexport async function getCompletions(\n situation: Situation,\n dataProvider: CompletionDataProvider\n): Promise<Completion[]> {\n switch (situation.type) {\n case 'EMPTY':\n case 'AT_ROOT':\n const historyCompletions = await getAllHistoryCompletions(dataProvider);\n return [\n ...historyCompletions,\n ...LOG_COMPLETIONS,\n ...AGGREGATION_COMPLETIONS,\n ...BUILT_IN_FUNCTIONS_COMPLETIONS,\n ...FUNCTION_COMPLETIONS,\n ];\n case 'IN_RANGE':\n return DURATION_COMPLETIONS;\n case 'IN_GROUPING':\n return getInGroupingCompletions(situation.logQuery, dataProvider);\n case 'IN_LABEL_SELECTOR_NO_LABEL_NAME':\n return getLabelNamesForSelectorCompletions(situation.otherLabels, dataProvider);\n case 'IN_LABEL_SELECTOR_WITH_LABEL_NAME':\n return getLabelValuesForMetricCompletions(\n situation.labelName,\n situation.betweenQuotes,\n situation.otherLabels,\n dataProvider\n );\n case 'AFTER_SELECTOR':\n return getAfterSelectorCompletions(situation.logQuery, situation.afterPipe, situation.hasSpace, dataProvider);\n case 'AFTER_UNWRAP':\n return getAfterUnwrapCompletions(situation.logQuery, dataProvider);\n case 'IN_AGGREGATION':\n return [...FUNCTION_COMPLETIONS, ...AGGREGATION_COMPLETIONS];\n case 'AFTER_KEEP_AND_DROP':\n return getAfterKeepAndDropCompletions(situation.logQuery, dataProvider);\n case 'IN_LOGFMT':\n return getLogfmtCompletions(\n situation.logQuery,\n situation.flags,\n situation.trailingComma,\n situation.trailingSpace,\n situation.otherLabels,\n dataProvider\n );\n default:\n throw new NeverCaseError(situation);\n }\n}\n","import type { SyntaxNode, TreeCursor } from '@lezer/common';\n\nimport {\n parser,\n VectorAggregationExpr,\n String,\n Selector,\n RangeAggregationExpr,\n Range,\n PipelineExpr,\n PipelineStage,\n Matchers,\n Matcher,\n LogQL,\n LogRangeExpr,\n LogExpr,\n Logfmt,\n Identifier,\n Grouping,\n Expr,\n LiteralExpr,\n MetricExpr,\n UnwrapExpr,\n DropLabelsExpr,\n KeepLabelsExpr,\n DropLabels,\n KeepLabels,\n ParserFlag,\n LabelExtractionExpression,\n LabelExtractionExpressionList,\n LogfmtExpressionParser,\n} from '@grafana/lezer-logql';\n\nimport { getLogQueryFromMetricsQueryAtPosition, getNodesFromQuery } from '../../../queryUtils';\n\ntype Direction = 'parent' | 'firstChild' | 'lastChild' | 'nextSibling';\ntype NodeType = number;\n\ntype Path = Array<[Direction, NodeType]>;\n\nfunction move(node: SyntaxNode, direction: Direction): SyntaxNode | null {\n return node[direction];\n}\n\n/**\n * Iteratively calls walk with given path until it returns null, then we return the last non-null node.\n * @param node\n * @param path\n */\nfunction traverse(node: SyntaxNode, path: Path): SyntaxNode | null {\n let current: SyntaxNode | null = node;\n let next = walk(current, path);\n while (next) {\n let nextTmp = walk(next, path);\n if (nextTmp) {\n next = nextTmp;\n } else {\n return next;\n }\n }\n return null;\n}\n\n/**\n * Walks a single step from the provided node, following the path.\n * @param node\n * @param path\n */\nfunction walk(node: SyntaxNode, path: Path): SyntaxNode | null {\n let current: SyntaxNode | null = node;\n for (const [direction, expectedNode] of path) {\n current = move(current, direction);\n if (current === null) {\n // we could not move in the direction, we stop\n return null;\n }\n if (current.type.id !== expectedNode) {\n // the reached node has wrong type, we stop\n return null;\n }\n }\n return current;\n}\n\nfunction getNodeText(node: SyntaxNode, text: string): string {\n return text.slice(node.from, node.to);\n}\n\nfunction parseStringLiteral(text: string): string {\n // If it is a string-literal, it is inside quotes of some kind\n const inside = text.slice(1, text.length - 1);\n\n // Very simple un-escaping:\n\n // Double quotes\n if (text.startsWith('\"') && text.endsWith('\"')) {\n // NOTE: this is not 100% perfect, we only unescape the double-quote,\n // there might be other characters too\n return inside.replace(/\\\\\"/gm, '\"');\n }\n\n // Single quotes\n if (text.startsWith(\"'\") && text.endsWith(\"'\")) {\n // NOTE: this is not 100% perfect, we only unescape the single-quote,\n // there might be other characters too\n return inside.replace(/\\\\'/gm, \"'\");\n }\n\n // Backticks\n if (text.startsWith('`') && text.endsWith('`')) {\n return inside;\n }\n\n throw new Error(`Invalid string literal: ${text}`);\n}\n\nexport type LabelOperator = '=' | '!=' | '=~' | '!~';\n\nexport type Label = {\n name: string;\n value: string;\n op: LabelOperator;\n};\n\nexport type Situation =\n | {\n type: 'EMPTY';\n }\n | {\n type: 'AT_ROOT';\n }\n | {\n type: 'IN_LOGFMT';\n otherLabels: string[];\n flags: boolean;\n trailingSpace: boolean;\n trailingComma: boolean;\n logQuery: string;\n }\n | {\n type: 'IN_RANGE';\n }\n | {\n type: 'IN_AGGREGATION';\n }\n | {\n type: 'IN_GROUPING';\n logQuery: string;\n }\n | {\n type: 'IN_LABEL_SELECTOR_NO_LABEL_NAME';\n otherLabels: Label[];\n }\n | {\n type: 'IN_LABEL_SELECTOR_WITH_LABEL_NAME';\n labelName: string;\n betweenQuotes: boolean;\n otherLabels: Label[];\n }\n | {\n type: 'AFTER_SELECTOR';\n afterPipe: boolean;\n hasSpace: boolean;\n logQuery: string;\n }\n | {\n type: 'AFTER_UNWRAP';\n logQuery: string;\n }\n | {\n type: 'AFTER_KEEP_AND_DROP';\n logQuery: string;\n };\n\ntype Resolver = {\n paths: NodeType[][];\n fun: (node: SyntaxNode, text: string, pos: number) => Situation | null;\n};\n\nfunction isPathMatch(resolverPath: NodeType[], cursorPath: number[]): boolean {\n return resolverPath.every((item, index) => item === cursorPath[index]);\n}\n\nconst ERROR_NODE_ID = 0;\n\nconst RESOLVERS: Resolver[] = [\n {\n paths: [\n [Selector],\n [Selector, Matchers],\n [Matchers],\n [ERROR_NODE_ID, Matchers],\n [ERROR_NODE_ID, Matchers, Selector],\n ],\n fun: resolveSelector,\n },\n {\n paths: [\n [LogQL],\n [RangeAggregationExpr],\n [ERROR_NODE_ID, LogRangeExpr, RangeAggregationExpr],\n [ERROR_NODE_ID, LabelExtractionExpressionList],\n [LogRangeExpr],\n [ERROR_NODE_ID, LabelExtractionExpressionList],\n [LabelExtractionExpressionList],\n [LogfmtExpressionParser],\n ],\n fun: resolveLogfmtParser,\n },\n {\n paths: [[LogQL], [ERROR_NODE_ID, Selector]],\n fun: resolveTopLevel,\n },\n {\n paths: [[String, Matcher]],\n fun: resolveMatcher,\n },\n {\n paths: [[Grouping]],\n fun: resolveLabelsForGrouping,\n },\n {\n paths: [[LogRangeExpr]],\n fun: resolveLogRange,\n },\n {\n paths: [\n [ERROR_NODE_ID, Matcher],\n [ERROR_NODE_ID, Matchers, Selector],\n ],\n fun: resolveMatcher,\n },\n {\n paths: [[ERROR_NODE_ID, Range]],\n fun: resolveDurations,\n },\n {\n paths: [[ERROR_NODE_ID, LogRangeExpr]],\n fun: resolveLogRangeFromError,\n },\n {\n paths: [[ERROR_NODE_ID, LiteralExpr, MetricExpr, VectorAggregationExpr]],\n fun: () => ({ type: 'IN_AGGREGATION' }),\n },\n {\n paths: [\n [ERROR_NODE_ID, PipelineStage, PipelineExpr],\n [PipelineStage, PipelineExpr],\n ],\n fun: resolvePipeError,\n },\n {\n paths: [[ERROR_NODE_ID, UnwrapExpr], [UnwrapExpr]],\n fun: resolveAfterUnwrap,\n },\n {\n paths: [\n [ERROR_NODE_ID, DropLabelsExpr],\n [ERROR_NODE_ID, DropLabels],\n [ERROR_NODE_ID, KeepLabelsExpr],\n [ERROR_NODE_ID, KeepLabels],\n ],\n fun: resolveAfterKeepAndDrop,\n },\n];\n\nconst LABEL_OP_MAP = new Map<string, LabelOperator>([\n ['Eq', '='],\n ['Re', '=~'],\n ['Neq', '!='],\n ['Nre', '!~'],\n]);\n\nfunction getLabelOp(opNode: SyntaxNode): LabelOperator | null {\n return LABEL_OP_MAP.get(opNode.name) ?? null;\n}\n\nfunction getLabel(matcherNode: SyntaxNode, text: string): Label | null {\n if (matcherNode.type.id !== Matcher) {\n return null;\n }\n\n const nameNode = walk(matcherNode, [['firstChild', Identifier]]);\n\n if (nameNode === null) {\n return null;\n }\n\n const opNode = nameNode.nextSibling;\n if (opNode === null) {\n return null;\n }\n\n const op = getLabelOp(opNode);\n if (op === null) {\n return null;\n }\n\n const valueNode = walk(matcherNode, [['lastChild', String]]);\n\n if (valueNode === null) {\n return null;\n }\n\n const name = getNodeText(nameNode, text);\n const value = parseStringLiteral(getNodeText(valueNode, text));\n\n return { name, value, op };\n}\n\nfunction getLabels(selectorNode: SyntaxNode, text: string): Label[] {\n if (selectorNode.type.id !== Selector && selectorNode.type.id !== Matchers) {\n return [];\n }\n\n let listNode: SyntaxNode | null = null;\n\n // If parent node is selector, we want to start with the current Matcher node\n if (selectorNode?.parent?.type.id === Selector) {\n listNode = selectorNode;\n } else {\n // Parent node needs to be returned first because otherwise both of the other walks will return a non-null node and this function will return the labels on the left side of the current node, the other two walks should be mutually exclusive when the parent is null\n listNode =\n // Node in-between labels\n traverse(selectorNode, [['parent', Matchers]]) ??\n // Node after all other labels\n walk(selectorNode, [['firstChild', Matchers]]) ??\n // Node before all other labels\n walk(selectorNode, [['lastChild', Matchers]]);\n }\n\n const labels: Label[] = [];\n\n while (listNode !== null) {\n const matcherNode = walk(listNode, [['lastChild', Matcher]]);\n if (matcherNode !== null) {\n const label = getLabel(matcherNode, text);\n if (label !== null) {\n labels.push(label);\n }\n }\n\n // there might be more labels\n listNode = walk(listNode, [['firstChild', Matchers]]);\n }\n\n // our labels-list is last-first, so we reverse it\n labels.reverse();\n\n return labels;\n}\n\nfunction resolveAfterUnwrap(node: SyntaxNode, text: string, pos: number): Situation | null {\n return {\n type: 'AFTER_UNWRAP',\n logQuery: getLogQueryFromMetricsQueryAtPosition(text, pos).trim(),\n };\n}\n\nfunction resolvePipeError(node: SyntaxNode, text: string, pos: number): Situation | null {\n /**\n * Examples:\n * - {level=\"info\"} |^\n * - count_over_time({level=\"info\"} |^ [4m])\n */\n let exprNode: SyntaxNode | null = null;\n if (node.type.id === ERROR_NODE_ID) {\n exprNode = walk(node, [\n ['parent', PipelineStage],\n ['parent', PipelineExpr],\n ]);\n } else if (node.type.id === PipelineStage) {\n exprNode = walk(node, [['parent', PipelineExpr]]);\n }\n\n if (exprNode?.parent?.type.id === LogExpr || exprNode?.parent?.type.id === LogRangeExpr) {\n return resolveLogOrLogRange(exprNode.parent, text, pos, true);\n }\n\n return null;\n}\n\nfunction resolveLabelsForGrouping(node: SyntaxNode, text: string, pos: number): Situation | null {\n const aggrExpNode = walk(node, [['parent', VectorAggregationExpr]]);\n if (aggrExpNode === null) {\n return null;\n }\n const bodyNode = aggrExpNode.getChild('MetricExpr');\n if (bodyNode === null) {\n return null;\n }\n\n const selectorNode = walk(bodyNode, [\n ['firstChild', RangeAggregationExpr],\n ['lastChild', LogRangeExpr],\n ['firstChild', Selector],\n ]);\n\n if (selectorNode === null) {\n return null;\n }\n\n return {\n type: 'IN_GROUPING',\n logQuery: getLogQueryFromMetricsQueryAtPosition(text, pos).trim(),\n };\n}\n\nfunction resolveMatcher(node: SyntaxNode, text: string, pos: number): Situation | null {\n // we can arrive here for two reasons. `node` is either:\n // - a StringNode (like in `{job=\"^\"}`)\n // - or an error node (like in `{job=^}`)\n const inStringNode = !node.type.isError;\n\n const parent = walk(node, [['parent', Matcher]]);\n if (parent === null) {\n return null;\n }\n\n const labelNameNode = walk(parent, [['firstChild', Identifier]]);\n if (labelNameNode === null) {\n return null;\n }\n\n const labelName = getNodeText(labelNameNode, text);\n\n // now we need to go up, to the parent of Matcher,\n // there can be one or many `Matchers` parents, we have\n // to go through all of them\n\n const firstListNode = walk(parent, [['parent', Matchers]]);\n if (firstListNode === null) {\n return null;\n }\n\n let listNode = firstListNode;\n\n // we keep going through the parent-nodes as long as they are Matchers.\n // as soon as we reach Selector, we stop\n let selectorNode: SyntaxNode | null = null;\n while (selectorNode === null) {\n const parent = listNode.parent;\n if (parent === null) {\n return null;\n }\n\n switch (parent.type.id) {\n case Matchers:\n //we keep looping\n listNode = parent;\n continue;\n case Selector:\n // we reached the end, we can stop the loop\n selectorNode = parent;\n continue;\n default:\n // we reached some other node, we stop\n return null;\n }\n }\n\n // now we need to find the other names\n const allLabels = getLabels(selectorNode, text);\n\n // we need to remove \"our\" label from all-labels, if it is in there\n const otherLabels = allLabels.filter((label) => label.name !== labelName);\n\n return {\n type: 'IN_LABEL_SELECTOR_WITH_LABEL_NAME',\n labelName,\n betweenQuotes: inStringNode,\n otherLabels,\n };\n}\n\nfunction resolveLogfmtParser(_: SyntaxNode, text: string, cursorPosition: number): Situation | null {\n // We want to know if the cursor if after a log query with logfmt parser.\n // E.g. `{x=\"y\"} | logfmt ^`\n /**\n * Wait until the user adds a space to be sure of what the last identifier is. Otherwise\n * it creates suggestion bugs with queries like {label=\"value\"} | parser^ suggest \"parser\"\n * and it can be inserted with extra pipes or commas.\n */\n const tree = parser.parse(text);\n\n // Adjust the cursor position if there are spaces at the end of the text.\n const trimRightTextLen = text.substring(0, cursorPosition).trimEnd().length;\n const position = trimRightTextLen < cursorPosition ? trimRightTextLen : cursorPosition;\n\n const cursor = tree.cursorAt(position);\n\n // Check if the user cursor is in any node that requires logfmt suggestions.\n const expectedNodes = [Logfmt, ParserFlag, LabelExtractionExpression, LabelExtractionExpressionList];\n let inLogfmt = false;\n do {\n const { node } = cursor;\n if (!expectedNodes.includes(node.type.id)) {\n continue;\n }\n if (cursor.from <= position && cursor.to >= position) {\n inLogfmt = true;\n break;\n }\n } while (cursor.next());\n\n if (!inLogfmt) {\n return null;\n }\n\n const flags = getNodesFromQuery(text, [ParserFlag]).length > 1;\n const labelNodes = getNodesFromQuery(text, [LabelExtractionExpression]);\n const otherLabels = labelNodes\n .map((label: SyntaxNode) => label.getChild(Identifier))\n .filter((label: SyntaxNode | null): label is SyntaxNode => label !== null)\n .map((label: SyntaxNode) => getNodeText(label, text));\n\n const logQuery = getLogQueryFromMetricsQueryAtPosition(text, position).trim();\n const trailingSpace = text.charAt(cursorPosition - 1) === ' ';\n const trailingComma = text.trimEnd().charAt(position - 1) === ',';\n\n return {\n type: 'IN_LOGFMT',\n otherLabels,\n flags,\n trailingSpace,\n trailingComma,\n logQuery,\n };\n}\n\nfunction resolveTopLevel(node: SyntaxNode, text: string, pos: number): Situation | null {\n /**\n * The following queries trigger resolveTopLevel().\n * - Empty query\n * - {label=\"value\"} ^\n * - {label=\"value\"} | parser ^\n * From here, we need to determine if the user is in a resolveLogOrLogRange() or simply at the root.\n */\n const logExprNode = walk(node, [\n ['lastChild', Expr],\n ['lastChild', LogExpr],\n ]);\n\n /**\n * Wait until the user adds a space to be sure of what the last identifier is. Otherwise\n * it creates suggestion bugs with queries like {label=\"value\"} | parser^ suggest \"parser\"\n * and it can be inserted with extra pipes.\n */\n if (logExprNode != null && text.endsWith(' ')) {\n return resolveLogOrLogRange(logExprNode, text, pos, false);\n }\n\n // `s` situation, with the cursor at the end.\n // (basically, user enters a non-special characters as first\n // character in query field)\n const idNode = walk(node, [\n ['firstChild', ERROR_NODE_ID],\n ['firstChild', Identifier],\n ]);\n\n if (idNode != null) {\n return {\n type: 'AT_ROOT',\n };\n }\n\n // no patterns match\n return null;\n}\n\nfunction resolveDurations(node: SyntaxNode, text: string, pos: number): Situation {\n return {\n type: 'IN_RANGE',\n };\n}\n\nfunction resolveLogRange(node: SyntaxNode, text: string, pos: number): Situation | null {\n const partialQuery = text.substring(0, pos).trimEnd();\n const afterPipe = partialQuery.endsWith('|');\n\n return resolveLogOrLogRange(node, text, pos, afterPipe);\n}\n\nfunction resolveLogRangeFromError(node: SyntaxNode, text: string, pos: number): Situation | null {\n const parent = walk(node, [['parent', LogRangeExpr]]);\n if (parent === null) {\n return null;\n }\n\n const partialQuery = text.substring(0, pos).trimEnd();\n const afterPipe = partialQuery.endsWith('|');\n\n return resolveLogOrLogRange(parent, text, pos, afterPipe);\n}\n\nfunction resolveLogOrLogRange(node: SyntaxNode, text: string, pos: number, afterPipe: boolean): Situation | null {\n // Here the `node` is either a LogExpr or a LogRangeExpr\n // We want to handle the case where we are next to a selector\n const selectorNode = walk(node, [['firstChild', Selector]]);\n\n // Check that the selector is before the cursor, not after it\n if (!selectorNode || selectorNode.to > pos) {\n return null;\n }\n\n return {\n type: 'AFTER_SELECTOR',\n afterPipe,\n hasSpace: text.charAt(pos - 1) === ' ',\n logQuery: getLogQueryFromMetricsQueryAtPosition(text, pos).trim(),\n };\n}\n\nfunction resolveSelector(node: SyntaxNode, text: string, pos: number): Situation | null {\n // for example `{^}`\n\n // false positive:\n // `{a=\"1\"^}`\n const child = walk(node, [['firstChild', Matchers]]);\n if (child !== null) {\n // means the label-matching part contains at least one label already.\n //\n // in this case, we will need to have a `,` character at the end,\n // to be able to suggest adding the next label.\n // the area between the end-of-the-child-node and the cursor-pos\n // must contain a `,` in this case.\n const textToCheck = text.slice(child.from, pos);\n if (!textToCheck.trim().endsWith(',')) {\n return null;\n }\n }\n\n const selectorNode = node.type.id === ERROR_NODE_ID ? walk(node, [['parent', Matchers]]) : node;\n if (!selectorNode) {\n return null;\n }\n\n const otherLabels = getLabels(selectorNode, text);\n\n return {\n type: 'IN_LABEL_SELECTOR_NO_LABEL_NAME',\n otherLabels,\n };\n}\n\nfunction resolveAfterKeepAndDrop(node: SyntaxNode, text: string, pos: number): Situation | null {\n let logQuery = getLogQueryFromMetricsQueryAtPosition(text, pos).trim();\n let keepAndDropParent: SyntaxNode | null = null;\n let parent = node.parent;\n while (parent !== null) {\n if (parent.type.id === PipelineStage) {\n keepAndDropParent = parent;\n break;\n }\n parent = parent.parent;\n }\n\n if (keepAndDropParent?.type.id === PipelineStage) {\n logQuery = logQuery.slice(0, keepAndDropParent.from);\n }\n\n return {\n type: 'AFTER_KEEP_AND_DROP',\n logQuery,\n };\n}\n\n// If there is an error in the current cursor position, it's likely that the user is\n// in the middle of writing a query. If we can't find an error node, we use the node\n// at the cursor position to identify the situation.\nfunction resolveCursor(text: string, cursorPos: number): TreeCursor {\n // Sometimes the cursor is a couple spaces after the end of the expression.\n // To account for this situation, we \"move\" the cursor position back to the real end\n // of the expression.\n const trimRightTextLen = text.trimEnd().length;\n const pos = trimRightTextLen < cursorPos ? trimRightTextLen : cursorPos;\n\n const tree = parser.parse(text);\n const cursor = tree.cursorAt(pos);\n\n do {\n if (cursor.from === pos && cursor.to === pos && cursor.node.type.isError) {\n return cursor;\n }\n } while (cursor.next());\n\n return tree.cursorAt(pos);\n}\n\nexport function getSituation(text: string, pos: number): Situation | null {\n // there is a special case when we are at the start of writing text,\n // so we handle that case first\n\n if (text === '') {\n return {\n type: 'EMPTY',\n };\n }\n\n const cursor = resolveCursor(text, pos);\n const currentNode = cursor.node;\n\n const ids = [cursor.type.id];\n while (cursor.parent()) {\n ids.push(cursor.type.id);\n }\n\n for (let resolver of RESOLVERS) {\n for (let path of resolver.paths) {\n if (isPathMatch(path, ids)) {\n const situation = resolver.fun(currentNode, text, pos);\n if (situation) {\n return situation;\n }\n }\n }\n }\n\n return null;\n}\n","import type { Monaco, monacoTypes } from '@grafana/ui';\n\nimport { CompletionDataProvider } from './CompletionDataProvider';\nimport { NeverCaseError } from './NeverCaseError';\nimport { CompletionType, getCompletions } from './completions';\nimport { getSituation, Situation } from './situation';\n\n// from: monacoTypes.languages.CompletionItemInsertTextRule.InsertAsSnippet\nconst INSERT_AS_SNIPPET_ENUM_VALUE = 4;\n\nexport function getSuggestOptions(): monacoTypes.editor.ISuggestOptions {\n return {\n // monaco-editor sometimes provides suggestions automatically, i am not\n // sure based on what, seems to be by analyzing the words already\n // written.\n // to try it out:\n // - enter `go_goroutines{job~`\n // - have the cursor at the end of the string\n // - press ctrl-enter\n // - you will get two suggestions\n // those were not provided by grafana, they are offered automatically.\n // i want to remove those. the only way i found is:\n // - every suggestion-item has a `kind` attribute,\n // that controls the icon to the left of the suggestion.\n // - items auto-generated by monaco have `kind` set to `text`.\n // - we make sure grafana-provided suggestions do not have `kind` set to `text`.\n // - and then we tell monaco not to show suggestions of kind `text`\n showWords: false,\n };\n}\n\nfunction getMonacoCompletionItemKind(type: CompletionType, monaco: Monaco): monacoTypes.languages.CompletionItemKind {\n switch (type) {\n case 'DURATION':\n return monaco.languages.CompletionItemKind.Unit;\n case 'FUNCTION':\n return monaco.languages.CompletionItemKind.Variable;\n case 'HISTORY':\n return monaco.languages.CompletionItemKind.Snippet;\n case 'LABEL_NAME':\n return monaco.languages.CompletionItemKind.Enum;\n case 'LABEL_VALUE':\n return monaco.languages.CompletionItemKind.EnumMember;\n case 'PATTERN':\n return monaco.languages.CompletionItemKind.Constructor;\n case 'PARSER':\n return monaco.languages.CompletionItemKind.Class;\n case 'LINE_FILTER':\n return monaco.languages.CompletionItemKind.TypeParameter;\n case 'PIPE_OPERATION':\n return monaco.languages.CompletionItemKind.Interface;\n default:\n throw new NeverCaseError(type);\n }\n}\n\nexport function getCompletionProvider(\n monaco: Monaco,\n dataProvider: CompletionDataProvider\n): monacoTypes.languages.CompletionItemProvider {\n const provideCompletionItems = (\n model: monacoTypes.editor.ITextModel,\n position: monacoTypes.Position\n ): monacoTypes.languages.ProviderResult<monacoTypes.languages.CompletionList> => {\n const word = model.getWordAtPosition(position);\n const wordUntil = model.getWordUntilPosition(position);\n\n // documentation says `position` will be \"adjusted\" in `getOffsetAt`\n // i don't know what that means, to be sure i clone it\n const positionClone = {\n column: position.column,\n lineNumber: position.lineNumber,\n };\n const offset = model.getOffsetAt(positionClone);\n const situation = getSituation(model.getValue(), offset);\n const range = calculateRange(situation, word, wordUntil, monaco, position);\n const completionsPromise = situation != null ? getCompletions(situation, dataProvider) : Promise.resolve([]);\n return completionsPromise.then((items) => {\n // monaco by default alphabetically orders the items.\n // to stop it, we use a number-as-string sortkey,\n // so that monaco keeps the order we use\n const maxIndexDigits = items.length.toString().length;\n const suggestions: monacoTypes.languages.CompletionItem[] = items.map((item, index) => ({\n kind: getMonacoCompletionItemKind(item.type, monaco),\n label: item.label,\n insertText: item.insertText,\n insertTextRules: item.isSnippet ? INSERT_AS_SNIPPET_ENUM_VALUE : undefined,\n detail: item.detail,\n documentation: item.documentation,\n sortText: index.toString().padStart(maxIndexDigits, '0'), // to force the order we have\n range: range,\n command: item.triggerOnInsert\n ? {\n id: 'editor.action.triggerSuggest',\n title: '',\n }\n : undefined,\n }));\n return { suggestions };\n });\n };\n\n return {\n triggerCharacters: ['{', ',', '[', '(', '=', '~', ' ', '\"', '|'],\n provideCompletionItems,\n };\n}\n\nexport const calculateRange = (\n situation: Situation | null,\n word: monacoTypes.editor.IWordAtPosition | null,\n wordUntil: monacoTypes.editor.IWordAtPosition,\n monaco: Monaco,\n position: monacoTypes.Position\n): monacoTypes.Range => {\n if (\n situation &&\n situation?.type === 'IN_LABEL_SELECTOR_WITH_LABEL_NAME' &&\n 'betweenQuotes' in situation &&\n situation.betweenQuotes\n ) {\n // Word until won't have second quote if they are between quotes\n const indexOfFirstQuote = wordUntil?.word?.indexOf('\"') ?? 0;\n\n const indexOfLastQuote = word?.word?.lastIndexOf('\"') ?? 0;\n\n const indexOfEquals = word?.word.indexOf('=');\n const indexOfLastEquals = word?.word.lastIndexOf('=');\n\n // Just one equals \"=\" the cursor is somewhere within a label value\n // e.g. value=\"labe^l-value\" or value=\"^label-value\" etc\n // We want the word to include everything within the quotes, so the result from autocomplete overwrites the existing label value\n if (\n indexOfLastEquals === indexOfEquals &&\n indexOfFirstQuote !== -1 &&\n indexOfLastQuote !== -1 &&\n indexOfLastEquals !== -1\n ) {\n return word != null\n ? monaco.Range.lift({\n startLineNumber: position.lineNumber,\n endLineNumber: position.lineNumber,\n startColumn: wordUntil.startColumn + indexOfFirstQuote + 1,\n endColumn: wordUntil.startColumn + indexOfLastQuote,\n })\n : monaco.Range.fromPositions(position);\n }\n }\n\n if (situation && situation.type === 'IN_LABEL_SELECTOR_WITH_LABEL_NAME') {\n // Otherwise we want the range to be calculated as the cursor position, as we want to insert the autocomplete, instead of overwriting existing text\n // The cursor position is the length of the wordUntil\n return word != null\n ? monaco.Range.lift({\n startLineNumber: position.lineNumber,\n endLineNumber: position.lineNumber,\n startColumn: wordUntil.endColumn,\n endColumn: wordUntil.endColumn,\n })\n : monaco.Range.fromPositions(position);\n }\n\n // And for all other non-label cases, we want to use the word start and end column\n return word != null\n ? monaco.Range.lift({\n startLineNumber: position.lineNumber,\n endLineNumber: position.lineNumber,\n startColumn: word.startColumn,\n endColumn: word.endColumn,\n })\n : monaco.Range.fromPositions(position);\n};\n","import { css } from '@emotion/css';\nimport { debounce } from 'lodash';\nimport { useRef, useEffect } from 'react';\nimport { useLatest } from 'react-use';\nimport { v4 as uuidv4 } from 'uuid';\n\nimport { GrafanaTheme2 } from '@grafana/data';\nimport { selectors } from '@grafana/e2e-selectors';\nimport { parser } from '@grafana/lezer-logql';\nimport { languageConfiguration, monarchlanguage } from '@grafana/monaco-logql';\nimport { useTheme2, ReactMonacoEditor, Monaco, monacoTypes, MonacoEditor } from '@grafana/ui';\n\nimport { Props } from './MonacoQueryFieldProps';\nimport { getOverrideServices } from './getOverrideServices';\nimport { CompletionDataProvider } from './monaco-completion-provider/CompletionDataProvider';\nimport { getCompletionProvider, getSuggestOptions } from './monaco-completion-provider/completionUtils';\nimport { placeHolderScopedVars, validateQuery } from './monaco-completion-provider/validation';\n\nconst options: monacoTypes.editor.IStandaloneEditorConstructionOptions = {\n codeLens: false,\n contextmenu: false,\n // we need `fixedOverflowWidgets` because otherwise in grafana-dashboards\n // the popup is clipped by the panel-visualizations.\n fixedOverflowWidgets: true,\n folding: false,\n fontSize: 14,\n lineDecorationsWidth: 8, // used as \"padding-left\"\n lineNumbers: 'off',\n minimap: { enabled: false },\n overviewRulerBorder: false,\n overviewRulerLanes: 0,\n padding: {\n // these numbers were picked so that visually this matches the previous version\n // of the query-editor the best\n top: 4,\n bottom: 5,\n },\n renderLineHighlight: 'none',\n scrollbar: {\n vertical: 'hidden',\n verticalScrollbarSize: 8, // used as \"padding-right\"\n horizontal: 'hidden',\n horizontalScrollbarSize: 0,\n alwaysConsumeMouseWheel: false,\n },\n scrollBeyondLastLine: false,\n suggest: getSuggestOptions(),\n suggestFontSize: 12,\n wordWrap: 'on',\n};\n\n// this number was chosen by testing various values. it might be necessary\n// because of the width of the border, not sure.\n//it needs to do 2 things:\n// 1. when the editor is single-line, it should make the editor height be visually correct\n// 2. when the editor is multi-line, the editor should not be \"scrollable\" (meaning,\n// you do a scroll-movement in the editor, and it will scroll the content by a couple pixels\n// up & down. this we want to avoid)\nconst EDITOR_HEIGHT_OFFSET = 2;\n\nconst LANG_ID = 'logql';\n\n// we must only run the lang-setup code once\nlet LANGUAGE_SETUP_STARTED = false;\n\nexport const defaultWordPattern = /(-?\\d*\\.\\d\\w*)|([^`~!#%^&*()\\-=+\\[{\\]}\\\\|;:'\",.<>\\/?\\s]+)/g;\n\nfunction ensureLogQL(monaco: Monaco) {\n if (LANGUAGE_SETUP_STARTED === false) {\n LANGUAGE_SETUP_STARTED = true;\n monaco.languages.register({ id: LANG_ID });\n\n monaco.languages.setMonarchTokensProvider(LANG_ID, monarchlanguage);\n monaco.languages.setLanguageConfiguration(LANG_ID, {\n ...languageConfiguration,\n wordPattern: /(-?\\d*\\.\\d\\w*)|([^`~!#%^&*()+\\[{\\]}\\\\|;:',.<>\\/?\\s]+)/g,\n // Default: /(-?\\d*\\.\\d\\w*)|([^`~!#%^&*()\\-=+\\[{\\]}\\\\|;:'\",.<>\\/?\\s]+)/g\n // Removed `\"`, `=`, and `-`, from the exclusion list, so now the completion provider can decide to overwrite any matching words, or just insert text at the cursor\n });\n }\n}\n\nconst getStyles = (theme: GrafanaTheme2, placeholder: string) => {\n return {\n container: css({\n borderRadius: theme.shape.radius.default,\n border: `1px solid ${theme.components.input.borderColor}`,\n width: '100%',\n '.monaco-editor .suggest-widget': {\n minWidth: '50%',\n },\n overflow: 'hidden',\n }),\n placeholder: css({\n '::after': {\n content: `'${placeholder}'`,\n fontFamily: theme.typography.fontFamilyMonospace,\n opacity: 0.3,\n },\n }),\n };\n};\n\nconst MonacoQueryField = ({\n history,\n onBlur,\n onRunQuery,\n initialValue,\n datasource,\n placeholder,\n onChange,\n timeRange,\n}: Props) => {\n const id = uuidv4();\n // we need only one instance of `overrideServices` during the lifetime of the react component\n const overrideServicesRef = useRef(getOverrideServices());\n const containerRef = useRef<HTMLDivElement>(null);\n\n const langProviderRef = useLatest(datasource.languageProvider);\n const historyRef = useLatest(history);\n const onRunQueryRef = useLatest(onRunQuery);\n const onBlurRef = useLatest(onBlur);\n const completionDataProviderRef = useRef<CompletionDataProvider | null>(null);\n\n const autocompleteCleanupCallback = useRef<(() => void) | null>(null);\n\n const theme = useTheme2();\n const styles = getStyles(theme, placeholder);\n\n useEffect(() => {\n // when we unmount, we unregister the autocomplete-function, if it was registered\n return () => {\n autocompleteCleanupCallback.current?.();\n };\n }, []);\n\n useEffect(() => {\n if (completionDataProviderRef.current && timeRange) {\n completionDataProviderRef.current.setTimeRange(timeRange);\n }\n }, [timeRange]);\n\n const setPlaceholder = (monaco: Monaco, editor: MonacoEditor) => {\n const placeholderDecorators = [\n {\n range: new monaco.Range(1, 1, 1, 1),\n options: {\n className: styles.placeholder,\n isWholeLine: true,\n },\n },\n ];\n\n let decorators: string[] = [];\n\n const checkDecorators: () => void = () => {\n const model = editor.getModel();\n\n if (!model) {\n return;\n }\n\n const newDecorators = model.getValueLength() === 0 ? placeholderDecorators : [];\n decorators = model.deltaDecorations(decorators, newDecorators);\n };\n\n checkDecorators();\n editor.onDidChangeModelContent(checkDecorators);\n };\n\n const onTypeDebounced = debounce(async (query: string) => {\n onChange(query);\n }, 1000);\n\n return (\n <div\n data-testid={selectors.components.QueryField.container}\n className={styles.container}\n // NOTE: we will be setting inline-style-width/height on this element\n ref={containerRef}\n >\n <ReactMonacoEditor\n overrideServices={overrideServicesRef.current}\n options={options}\n language={LANG_ID}\n value={initialValue}\n beforeMount={(monaco) => {\n ensureLogQL(monaco);\n }}\n onMount={(editor, monaco) => {\n // Monaco has a bug where it runs actions on all instances (https://github.com/microsoft/monaco-editor/issues/2947), so we ensure actions are executed on instance-level with this ContextKey.\n const isEditorFocused = editor.createContextKey<boolean>('isEditorFocused' + id, false);\n // we setup on-blur\n editor.onDidBlurEditorWidget(() => {\n isEditorFocused.set(false);\n onBlurRef.current(editor.getValue());\n });\n editor.onDidChangeModelContent((e) => {\n const model = editor.getModel();\n if (!model) {\n return;\n }\n const query = model.getValue();\n const errors =\n validateQuery(\n query,\n datasource.interpolateString(query, placeHolderScopedVars),\n model.getLinesContent(),\n parser\n ) || [];\n\n const markers = errors.map(({ error, ...boundary }) => ({\n message: `${\n error ? `Error parsing \"${error}\"` : 'Parse error'\n }. The query appears to be incorrect and could fail to be executed.`,\n severity: monaco.MarkerSeverity.Error,\n ...boundary,\n }));\n\n onTypeDebounced(query);\n monaco.editor.setModelMarkers(model, 'owner', markers);\n });\n const dataProvider = new CompletionDataProvider(langProviderRef.current, historyRef, timeRange);\n completionDataProviderRef.current = dataProvider;\n const completionProvider = getCompletionProvider(monaco, dataProvider);\n\n // completion-providers in monaco are not registered directly to editor-instances,\n // they are registered to languages. this makes it hard for us to have\n // separate completion-providers for every query-field-instance\n // (but we need that, because they might connect to different datasources).\n // the trick we do is, we wrap the callback in a \"proxy\",\n // and in the proxy, the first thing is, we check if we are called from\n // \"our editor instance\", and if not, we just return nothing. if yes,\n // we call the completion-provider.\n const filteringCompletionProvider: monacoTypes.languages.CompletionItemProvider = {\n ...completionProvider,\n provideCompletionItems: (model, position, context, token) => {\n // if the model-id does not match, then this call is from a different editor-instance,\n // not \"our instance\", so return nothing\n if (editor.getModel()?.id !== model.id) {\n return { suggestions: [] };\n }\n return completionProvider.provideCompletionItems(model, position, context, token);\n },\n };\n\n const { dispose } = monaco.languages.registerCompletionItemProvider(LANG_ID, filteringCompletionProvider);\n\n autocompleteCleanupCallback.current = dispose;\n // this code makes the editor resize itself so that the content fits\n // (it will grow taller when necessary)\n // FIXME: maybe move this functionality into CodeEditor, like:\n // <CodeEditor resizingMode=\"single-line\"/>\n const handleResize = () => {\n const containerDiv = containerRef.current;\n if (containerDiv !== null) {\n const pixelHeight = editor.getContentHeight();\n containerDiv.style.height = `${pixelHeight + EDITOR_HEIGHT_OFFSET}px`;\n const pixelWidth = containerDiv.clientWidth;\n editor.layout({ width: pixelWidth, height: pixelHeight });\n }\n };\n\n editor.onDidContentSizeChange(handleResize);\n handleResize();\n // handle: shift + enter\n // FIXME: maybe move this functionality into CodeEditor?\n editor.addCommand(\n monaco.KeyMod.Shift | monaco.KeyCode.Enter,\n () => {\n onRunQueryRef.current(editor.getValue());\n },\n 'isEditorFocused' + id\n );\n\n // Fixes Monaco capturing the search key binding and displaying a useless search box within the Editor.\n // See https://github.com/grafana/grafana/issues/85850\n monaco.editor.addKeybindingRule({\n keybinding: monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyF,\n command: null,\n });\n\n editor.onDidFocusEditorText(() => {\n isEditorFocused.set(true);\n if (editor.getValue().trim() === '') {\n editor.trigger('', 'editor.action.triggerSuggest', {});\n }\n });\n\n setPlaceholder(monaco, editor);\n }}\n />\n </div>\n );\n};\n\n// Default export for lazy load.\nexport default MonacoQueryField;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.monarchlanguage = exports.languageConfiguration = void 0;\nexports.languageConfiguration = {\n // the default separators except `@$`\n wordPattern: /(-?\\d*\\.\\d\\w*)|([^`~!#%^&*()\\-=+\\[{\\]}\\\\|;:'\",.<>\\/?\\s]+)/g,\n comments: {\n lineComment: \"#\",\n },\n brackets: [\n [\"{\", \"}\"],\n [\"[\", \"]\"],\n [\"(\", \")\"],\n ],\n autoClosingPairs: [\n { open: \"{\", close: \"}\" },\n { open: \"[\", close: \"]\" },\n { open: \"(\", close: \")\" },\n { open: '\"', close: '\"' },\n { open: \"'\", close: \"'\" },\n { open: \"`\", close: \"`\" },\n ],\n surroundingPairs: [\n { open: \"{\", close: \"}\" },\n { open: \"[\", close: \"]\" },\n { open: \"(\", close: \")\" },\n { open: '\"', close: '\"' },\n { open: \"'\", close: \"'\" },\n { open: \"`\", close: \"`\" },\n { open: \"<\", close: \">\" },\n ],\n folding: {},\n};\n// LogQL built-in aggregation operators\n// https://grafana.com/docs/loki/latest/logql/metric_queries/#built-in-aggregation-operators\nvar aggregations = [\n \"sum\",\n \"avg\",\n \"min\",\n \"max\",\n \"stddev\",\n \"stdvar\",\n \"count\",\n \"topk\",\n \"bottomk\",\n];\n// LogQL parser expressions\n// https://grafana.com/docs/loki/latest/logql/log_queries/#parser-expression\nvar parsers = [\"json\", \"logfmt\", \"regexp\", \"unpack\", \"pattern\"];\n// LogQL format expressions\n// https://grafana.com/docs/loki/latest/logql/log_queries/#parser-expression\nvar format_expressions = [\"line_format\", \"label_format\"];\n// LogQL vector aggregations\n// https://grafana.com/docs/loki/latest/logql/metric_queries/#range-vector-aggregation\nvar vector_aggregations = [\n \"count_over_time\",\n \"rate\",\n \"bytes_over_time\",\n \"bytes_rate\",\n \"avg_over_time\",\n \"sum_over_time\",\n \"min_over_time\",\n \"max_over_time\",\n \"stdvar_over_time\",\n \"stddev_over_time\",\n \"quantile_over_time\",\n \"first_over_time\",\n \"last_over_time\",\n \"absent_over_time\",\n];\n// LogQL by and without clauses\nvar vector_matching = [\"by\", \"without\"];\n// Produce a regex matching elements : (by|without)\nvar vectorMatchingRegex = \"(\".concat(vector_matching.reduce(function (prev, curr) { return \"\".concat(prev, \"|\").concat(curr); }), \")\");\n// LogQL Operators\nvar operators = [\n \"+\",\n \"-\",\n \"*\",\n \"/\",\n \"%\",\n \"^\",\n \"==\",\n \"!=\",\n \">\",\n \"<\",\n \">=\",\n \"<=\",\n \"|=\",\n \"!=\",\n \"|~\",\n \"!~\",\n \"and\",\n \"or\",\n \"unless\",\n \"|\",\n];\n// Merging all the keywords in one list\nvar keywords = aggregations\n .concat(parsers)\n .concat(format_expressions)\n .concat(vector_aggregations)\n .concat(vector_matching);\nexports.monarchlanguage = {\n ignoreCase: false,\n defaultToken: \"\",\n tokenPostfix: \".logql\",\n keywords: keywords,\n operators: operators,\n vectorMatching: vectorMatchingRegex,\n // we include these common regular expressions\n symbols: /[=><!~?:&|+\\-*\\/^%]+/,\n escapes: /\\\\(?:[abfnrtv\\\\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,\n digits: /\\d+(_+\\d+)*/,\n octaldigits: /[0-7]+(_+[0-7]+)*/,\n binarydigits: /[0-1]+(_+[0-1]+)*/,\n hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,\n integersuffix: /(ll|LL|u|U|l|L)?(ll|LL|u|U|l|L)?/,\n floatsuffix: /[fFlL]?/,\n // The main tokenizer for our languages\n tokenizer: {\n root: [\n // 'by', 'without' and vector matching\n [/@vectorMatching\\s*(?=\\()/, \"type\", \"@clauses\"],\n // labels\n [/[a-z_]\\w*(?=\\s*(=|!=|=~|!~))/, \"tag\"],\n // comments\n [/(^#.*$)/, \"comment\"],\n // all keywords have the same color\n [\n /[a-zA-Z_]\\w*/,\n {\n cases: {\n \"@keywords\": \"type\",\n \"@default\": \"identifier\",\n },\n },\n ],\n // strings\n [/\"/, \"string\", \"@string_double\"],\n [/'/, \"string\", \"@string_single\"],\n [/`/, \"string\", \"@string_backtick\"],\n // whitespace\n { include: \"@whitespace\" },\n // delimiters and operators\n [/[{}()\\[\\]]/, \"@brackets\"],\n [/[<>](?!@symbols)/, \"@brackets\"],\n [\n /@symbols/,\n {\n cases: {\n \"@operators\": \"delimiter\",\n \"@default\": \"\",\n },\n },\n ],\n // numbers\n [/\\d+(?:\\.\\d)?(?:ms|ns|us|µs|[smhdwy])/, \"number\"],\n [/\\d+(?:\\.\\d)?(?:b|kib|Kib|kb|KB|mib|Mib|mb|MB|gib|Gib|gb|GB|tib|Tib|tb|TB|pib|Pib|pb|PB|eib|Eib|eb|EB])/, \"number\"],\n [/\\d*\\d+[eE]([\\-+]?\\d+)?(@floatsuffix)/, \"number.float\"],\n [/\\d*\\.\\d+([eE][\\-+]?\\d+)?(@floatsuffix)/, \"number.float\"],\n [/0[xX][0-9a-fA-F']*[0-9a-fA-F](@integersuffix)/, \"number.hex\"],\n [/0[0-7']*[0-7](@integersuffix)/, \"number.octal\"],\n [/0[bB][0-1']*[0-1](@integersuffix)/, \"number.binary\"],\n [/\\d[\\d']*\\d(@integersuffix)/, \"number\"],\n [/\\d(@integersuffix)/, \"number\"],\n ],\n string_double: [\n // Set to token: number to differentiate color\n [/\\{\\{(.*?)\\}\\}/, { token: 'number' }],\n [/[^\\\\\"]/, \"string\"],\n [/@escapes/, \"string.escape\"],\n [/\\\\./, \"string.escape.invalid\"],\n [/\"/, \"string\", \"@pop\"],\n ],\n string_single: [\n [/[^\\\\']+/, \"string\"],\n [/@escapes/, \"string.escape\"],\n [/\\\\./, \"string.escape.invalid\"],\n [/'/, \"string\", \"@pop\"],\n ],\n string_backtick: [\n // Set to token: number to differentiate color\n [/\\{\\{(.*?)\\}\\}/, { token: 'number' }],\n [/[^\\\\`]/, \"string\"],\n [/@escapes/, \"string.escape\"],\n [/\\\\./, \"string.escape.invalid\"],\n [/`/, \"string\", \"@pop\"],\n ],\n clauses: [\n [/[^(,)]/, \"tag\"],\n [/\\)/, \"identifier\", \"@pop\"],\n ],\n whitespace: [[/[ \\t\\r\\n]+/, \"white\"]],\n },\n};\n"],"names":["value","ref","useRef","current","overrideServices","storageService","strings","Map","set","toString","onDidChangeValue","data","onDidChangeTarget","onWillSaveState","get","key","scope","fallbackValue","getBoolean","val","undefined","getNumber","parseInt","store","target","delete","remove","keys","Array","from","logStorage","migrate","Promise","resolve","isNew","flush","reason","makeStorageService","CompletionDataProvider","buildSelector","labels","map","label","name","op","escapeLabelValueInExactSelector","join","setTimeRange","timeRange","this","queryToLabelKeysCache","clear","getHistory","chain","historyRef","orderBy","history","query","expr","trim","filter","uniq","getLabelNames","otherLabels","length","languageProvider","start","getLabelKeys","possibleLabelNames","fetchLabels","streamSelector","usedLabelNames","Set","l","has","getLabelValues","labelName","fetchLabelValues","logQuery","cachedLabelKeys","size","firstKey","next","labelKeys","getParserAndLabelKeys","constructor","NeverCaseError","Error","super","JSON","stringify","LOG_COMPLETIONS","type","insertText","isSnippet","triggerOnInsert","AGGREGATION_COMPLETIONS","AGGREGATION_OPERATORS","f","detail","documentation","FUNCTION_COMPLETIONS","RANGE_VEC_FUNCTIONS","BUILT_IN_FUNCTIONS_COMPLETIONS","BUILT_IN_FUNCTIONS","DURATION_COMPLETIONS","text","UNWRAP_FUNCTION_COMPLETIONS","LOGFMT_ARGUMENT_COMPLETIONS","LINE_FILTER_COMPLETIONS","operator","explainOperator","LokiOperationId","LineContains","afterPipe","LineContainsNot","LineMatchesRegex","LineMatchesRegexNot","getPipeOperationsCompletions","prefix","completions","push","LineFormat","LabelFormat","Unwrap","Decolorize","Drop","Keep","PARSERS","getParserCompletions","hasJSON","hasLogfmt","hasPack","extractedLabelKeys","hasParserInQuery","allParsers","hasLevelInExtractedLabels","some","extra","Unpack","Json","Logfmt","sort","forEach","parser","getAfterSelectorCompletions","hasSpace","dataProvider","trimEnd","structuredMetadataKeys","hasQueryParser","isQueryWithParser","queryWithParser","lineFilters","completion","replace","getLineFilterCompletions","getCompletions","situation","historyCompletions","getAllHistoryCompletions","getInGroupingCompletions","getLabelNamesForSelectorCompletions","betweenQuotes","getLabelValuesForMetricCompletions","unwrapLabelKeys","getAfterUnwrapCompletions","getAfterKeepAndDropCompletions","flags","trailingComma","trailingSpace","pipeOperations","parserCompletions","includes","labelPrefix","labelCompletions","getLogfmtCompletions","move","node","direction","walk","path","expectedNode","id","getNodeText","slice","to","isPathMatch","resolverPath","cursorPath","every","item","index","RESOLVERS","paths","Selector","Matchers","fun","pos","child","endsWith","selectorNode","getLabels","LogQL","RangeAggregationExpr","LogRangeExpr","LabelExtractionExpressionList","LogfmtExpressionParser","_","cursorPosition","tree","parse","trimRightTextLen","substring","position","cursor","cursorAt","expectedNodes","ParserFlag","LabelExtractionExpression","inLogfmt","getNodesFromQuery","getChild","Identifier","getLogQueryFromMetricsQueryAtPosition","charAt","logExprNode","Expr","LogExpr","resolveLogOrLogRange","String","Matcher","resolveMatcher","Grouping","aggrExpNode","VectorAggregationExpr","bodyNode","Range","parent","LiteralExpr","MetricExpr","PipelineStage","PipelineExpr","exprNode","UnwrapExpr","DropLabelsExpr","DropLabels","KeepLabelsExpr","KeepLabels","keepAndDropParent","LABEL_OP_MAP","getLabel","matcherNode","nameNode","opNode","nextSibling","getLabelOp","valueNode","inside","startsWith","parseStringLiteral","listNode","traverse","nextTmp","reverse","inStringNode","isError","labelNameNode","firstListNode","getSituation","cursorPos","resolveCursor","currentNode","ids","resolver","getMonacoCompletionItemKind","monaco","languages","CompletionItemKind","Unit","Variable","Snippet","Enum","EnumMember","Constructor","Class","TypeParameter","Interface","calculateRange","word","wordUntil","indexOfFirstQuote","indexOf","indexOfLastQuote","lastIndexOf","indexOfEquals","indexOfLastEquals","lift","startLineNumber","lineNumber","endLineNumber","startColumn","endColumn","fromPositions","options","codeLens","contextmenu","fixedOverflowWidgets","folding","fontSize","lineDecorationsWidth","lineNumbers","minimap","enabled","overviewRulerBorder","overviewRulerLanes","padding","top","bottom","renderLineHighlight","scrollbar","vertical","verticalScrollbarSize","horizontal","horizontalScrollbarSize","alwaysConsumeMouseWheel","scrollBeyondLastLine","suggest","showWords","suggestFontSize","wordWrap","LANG_ID","LANGUAGE_SETUP_STARTED","defaultWordPattern","onBlur","onRunQuery","initialValue","datasource","placeholder","onChange","uuidv4","overrideServicesRef","containerRef","langProviderRef","useLatest","onRunQueryRef","onBlurRef","completionDataProviderRef","autocompleteCleanupCallback","styles","theme","container","css","borderRadius","shape","radius","default","border","components","input","borderColor","width","minWidth","overflow","content","fontFamily","typography","fontFamilyMonospace","opacity","getStyles","useTheme2","useEffect","onTypeDebounced","debounce","div","data-testid","selectors","QueryField","className","ReactMonacoEditor","language","beforeMount","register","setMonarchTokensProvider","monarchlanguage","setLanguageConfiguration","languageConfiguration","wordPattern","ensureLogQL","onMount","editor","isEditorFocused","createContextKey","onDidBlurEditorWidget","getValue","onDidChangeModelContent","e","model","getModel","markers","validateQuery","interpolateString","placeHolderScopedVars","getLinesContent","error","boundary","message","severity","MarkerSeverity","setModelMarkers","completionProvider","triggerCharacters","provideCompletionItems","getWordAtPosition","getWordUntilPosition","positionClone","column","offset","getOffsetAt","range","then","items","maxIndexDigits","suggestions","kind","insertTextRules","sortText","padStart","command","title","getCompletionProvider","filteringCompletionProvider","context","token","dispose","registerCompletionItemProvider","handleResize","containerDiv","pixelHeight","getContentHeight","style","height","pixelWidth","clientWidth","layout","onDidContentSizeChange","addCommand","KeyMod","Shift","KeyCode","Enter","addKeybindingRule","keybinding","CtrlCmd","KeyF","onDidFocusEditorText","trigger","placeholderDecorators","isWholeLine","decorators","checkDecorators","newDecorators","getValueLength","deltaDecorations","setPlaceholder","exports","comments","lineComment","brackets","autoClosingPairs","open","close","surroundingPairs","vector_matching","vectorMatchingRegex","concat","reduce","prev","curr","keywords","ignoreCase","defaultToken","tokenPostfix","operators","vectorMatching","symbols","escapes","digits","octaldigits","binarydigits","hexdigits","integersuffix","floatsuffix","tokenizer","root","cases","include","string_double","string_single","string_backtick","clauses","whitespace"],"sourceRoot":""}