@grafana/scenes 6.7.0 → 6.8.0

package/dist/esm/src/variables/variants/query/QueryVariable.js

@@ -0,0 +1,139 @@
+import { lastValueFrom, of, from, mergeMap, filter, take, throwError, catchError } from 'rxjs';
+import { v4 } from 'uuid';
+import { VariableRefresh, VariableSort, LoadingState, CoreApp } from '@grafana/data';
+import { sceneGraph } from '../../../core/sceneGraph/index.js';
+import { VariableDependencyConfig } from '../../VariableDependencyConfig.js';
+import { renderSelectForVariable } from '../../components/VariableValueSelect.js';
+import { MultiValueVariable } from '../MultiValueVariable.js';
+import { createQueryVariableRunner } from './createQueryVariableRunner.js';
+import { metricNamesToVariableValues } from './utils.js';
+import { toMetricFindValues } from './toMetricFindValues.js';
+import { getDataSource } from '../../../utils/getDataSource.js';
+import { safeStringifyValue } from '../../utils.js';
+import { SEARCH_FILTER_VARIABLE } from '../../constants.js';
+import { debounce } from 'lodash';
+import { registerQueryWithController } from '../../../querying/registerQueryWithController.js';
+import { wrapInSafeSerializableSceneObject } from '../../../utils/wrapInSafeSerializableSceneObject.js';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+class QueryVariable extends MultiValueVariable {
+  constructor(initialState) {
+    super(__spreadValues({
+      type: "query",
+      name: "",
+      value: "",
+      text: "",
+      options: [],
+      datasource: null,
+      regex: "",
+      query: "",
+      refresh: VariableRefresh.onDashboardLoad,
+      sort: VariableSort.disabled
+    }, initialState));
+    this._variableDependency = new VariableDependencyConfig(this, {
+      statePaths: ["regex", "query", "datasource"]
+    });
+    this.onSearchChange = (searchFilter) => {
+      if (!containsSearchFilter(this.state.query)) {
+        return;
+      }
+      this._updateOptionsBasedOnSearchFilter(searchFilter);
+    };
+    this._updateOptionsBasedOnSearchFilter = debounce(async (searchFilter) => {
+      const result = await lastValueFrom(this.getValueOptions({ searchFilter }));
+      this.setState({ options: result, loading: false });
+    }, 400);
+  }
+  getValueOptions(args) {
+    if (!this.state.query) {
+      return of([]);
+    }
+    this.setState({ loading: true, error: null });
+    return from(
+      getDataSource(this.state.datasource, {
+        __sceneObject: wrapInSafeSerializableSceneObject(this)
+      })
+    ).pipe(
+      mergeMap((ds) => {
+        const runner = createQueryVariableRunner(ds);
+        const target = runner.getTarget(this);
+        const request = this.getRequest(target, args.searchFilter);
+        return runner.runRequest({ variable: this, searchFilter: args.searchFilter }, request).pipe(
+          registerQueryWithController({
+            type: "variable",
+            request,
+            origin: this
+          }),
+          filter((data) => data.state === LoadingState.Done || data.state === LoadingState.Error),
+          take(1),
+          mergeMap((data) => {
+            if (data.state === LoadingState.Error) {
+              return throwError(() => data.error);
+            }
+            return of(data);
+          }),
+          toMetricFindValues(),
+          mergeMap((values) => {
+            let regex = "";
+            if (this.state.regex) {
+              regex = sceneGraph.interpolate(this, this.state.regex, void 0, "regex");
+            }
+            return of(metricNamesToVariableValues(regex, this.state.sort, values));
+          }),
+          catchError((error) => {
+            if (error.cancelled) {
+              return of([]);
+            }
+            return throwError(() => error);
+          })
+        );
+      })
+    );
+  }
+  getRequest(target, searchFilter) {
+    const scopedVars = {
+      __sceneObject: wrapInSafeSerializableSceneObject(this)
+    };
+    if (searchFilter) {
+      scopedVars.__searchFilter = { value: searchFilter, text: searchFilter };
+    }
+    const range = sceneGraph.getTimeRange(this).state.value;
+    const request = {
+      app: CoreApp.Dashboard,
+      requestId: v4(),
+      timezone: "",
+      range,
+      interval: "",
+      intervalMs: 0,
+      targets: [target],
+      scopedVars,
+      startTime: Date.now()
+    };
+    return request;
+  }
+}
+QueryVariable.Component = ({ model }) => {
+  return renderSelectForVariable(model);
+};
+function containsSearchFilter(query) {
+  const str = safeStringifyValue(query);
+  return str.indexOf(SEARCH_FILTER_VARIABLE) > -1;
+}
+
+export { QueryVariable };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"QueryVariable.js","sources":["../../../../../../src/variables/variants/query/QueryVariable.tsx"],"sourcesContent":["import { Observable, of, filter, take, mergeMap, catchError, throwError, from, lastValueFrom } from 'rxjs';\nimport { v4 as uuidv4 } from 'uuid';\n\nimport {\n  CoreApp,\n  DataQueryRequest,\n  LoadingState,\n  PanelData,\n  ScopedVars,\n  VariableRefresh,\n  VariableSort,\n} from '@grafana/data';\n\nimport { sceneGraph } from '../../../core/sceneGraph';\nimport { SceneComponentProps, SceneDataQuery } from '../../../core/types';\nimport { VariableDependencyConfig } from '../../VariableDependencyConfig';\nimport { renderSelectForVariable } from '../../components/VariableValueSelect';\nimport { VariableValueOption } from '../../types';\nimport { MultiValueVariable, MultiValueVariableState, VariableGetOptionsArgs } from '../MultiValueVariable';\n\nimport { createQueryVariableRunner } from './createQueryVariableRunner';\nimport { metricNamesToVariableValues } from './utils';\nimport { toMetricFindValues } from './toMetricFindValues';\nimport { getDataSource } from '../../../utils/getDataSource';\nimport { safeStringifyValue } from '../../utils';\nimport { DataQuery, DataSourceRef } from '@grafana/schema';\nimport { SEARCH_FILTER_VARIABLE } from '../../constants';\nimport { debounce } from 'lodash';\nimport { registerQueryWithController } from '../../../querying/registerQueryWithController';\nimport { wrapInSafeSerializableSceneObject } from '../../../utils/wrapInSafeSerializableSceneObject';\n\nexport interface QueryVariableState extends MultiValueVariableState {\n  type: 'query';\n  datasource: DataSourceRef | null;\n  query: string | SceneDataQuery;\n  regex: string;\n  refresh: VariableRefresh;\n  sort: VariableSort;\n  /** @internal Only for use inside core dashboards */\n  definition?: string;\n}\n\nexport class QueryVariable extends MultiValueVariable<QueryVariableState> {\n  protected _variableDependency = new VariableDependencyConfig(this, {\n    statePaths: ['regex', 'query', 'datasource'],\n  });\n\n  public constructor(initialState: Partial<QueryVariableState>) {\n    super({\n      type: 'query',\n      name: '',\n      value: '',\n      text: '',\n      options: [],\n      datasource: null,\n      regex: '',\n      query: '',\n      refresh: VariableRefresh.onDashboardLoad,\n      sort: VariableSort.disabled,\n      ...initialState,\n    });\n  }\n\n  public getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]> {\n    if (!this.state.query) {\n      return of([]);\n    }\n\n    this.setState({ loading: true, error: null });\n\n    return from(\n      getDataSource(this.state.datasource, {\n        __sceneObject: wrapInSafeSerializableSceneObject(this),\n      })\n    ).pipe(\n      mergeMap((ds) => {\n        const runner = createQueryVariableRunner(ds);\n        const target = runner.getTarget(this);\n        const request = this.getRequest(target, args.searchFilter);\n\n        return runner.runRequest({ variable: this, searchFilter: args.searchFilter }, request).pipe(\n          registerQueryWithController({\n            type: 'variable',\n            request: request,\n            origin: this,\n          }),\n          filter((data) => data.state === LoadingState.Done || data.state === LoadingState.Error), // we only care about done or error for now\n          take(1), // take the first result, using first caused a bug where it in some situations throw an uncaught error because of no results had been received yet\n          mergeMap((data: PanelData) => {\n            if (data.state === LoadingState.Error) {\n              return throwError(() => data.error);\n            }\n            return of(data);\n          }),\n          toMetricFindValues(),\n          mergeMap((values) => {\n            let regex = '';\n            if (this.state.regex) {\n              regex = sceneGraph.interpolate(this, this.state.regex, undefined, 'regex');\n            }\n            return of(metricNamesToVariableValues(regex, this.state.sort, values));\n          }),\n          catchError((error) => {\n            if (error.cancelled) {\n              return of([]);\n            }\n            return throwError(() => error);\n          })\n        );\n      })\n    );\n  }\n\n  private getRequest(target: DataQuery | string, searchFilter?: string) {\n    const scopedVars: ScopedVars = {\n      __sceneObject: wrapInSafeSerializableSceneObject(this),\n    };\n\n    if (searchFilter) {\n      scopedVars.__searchFilter = { value: searchFilter, text: searchFilter };\n    }\n\n    const range = sceneGraph.getTimeRange(this).state.value;\n\n    const request: DataQueryRequest = {\n      app: CoreApp.Dashboard,\n      requestId: uuidv4(),\n      timezone: '',\n      range,\n      interval: '',\n      intervalMs: 0,\n      // @ts-ignore\n      targets: [target],\n      scopedVars,\n      startTime: Date.now(),\n    };\n\n    return request;\n  }\n\n  onSearchChange = (searchFilter: string) => {\n    if (!containsSearchFilter(this.state.query)) {\n      return;\n    }\n\n    this._updateOptionsBasedOnSearchFilter(searchFilter);\n  };\n\n  private _updateOptionsBasedOnSearchFilter = debounce(async (searchFilter: string) => {\n    const result = await lastValueFrom(this.getValueOptions({ searchFilter }));\n    this.setState({ options: result, loading: false });\n  }, 400);\n\n  public static Component = ({ model }: SceneComponentProps<MultiValueVariable>) => {\n    return renderSelectForVariable(model);\n  };\n}\n\nfunction containsSearchFilter(query: string | DataQuery) {\n  const str = safeStringifyValue(query);\n  return str.indexOf(SEARCH_FILTER_VARIABLE) > -1;\n}\n"],"names":["uuidv4"],"mappings":"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"}

package/dist/esm/src/variables/variants/query/createQueryVariableRunner.js

@@ -0,0 +1,129 @@
+import { from, mergeMap, of } from 'rxjs';
+import { LoadingState, getDefaultTimeRange } from '@grafana/data';
+import { getRunRequest } from '@grafana/runtime';
+import { hasStandardVariableSupport, hasLegacyVariableSupport, hasCustomVariableSupport } from './guards.js';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+class StandardQueryRunner {
+  constructor(datasource, _runRequest = getRunRequest()) {
+    this.datasource = datasource;
+    this._runRequest = _runRequest;
+  }
+  getTarget(variable) {
+    if (hasStandardVariableSupport(this.datasource)) {
+      return this.datasource.variables.toDataQuery(ensureVariableQueryModelIsADataQuery(variable));
+    }
+    throw new Error("Couldn't create a target with supplied arguments.");
+  }
+  runRequest(_, request) {
+    if (!hasStandardVariableSupport(this.datasource)) {
+      return getEmptyMetricFindValueObservable();
+    }
+    if (!this.datasource.variables.query) {
+      return this._runRequest(this.datasource, request);
+    }
+    return this._runRequest(this.datasource, request, this.datasource.variables.query.bind(this.datasource.variables));
+  }
+}
+class LegacyQueryRunner {
+  constructor(datasource) {
+    this.datasource = datasource;
+  }
+  getTarget(variable) {
+    if (hasLegacyVariableSupport(this.datasource)) {
+      return variable.state.query;
+    }
+    throw new Error("Couldn't create a target with supplied arguments.");
+  }
+  runRequest({ variable, searchFilter }, request) {
+    if (!hasLegacyVariableSupport(this.datasource)) {
+      return getEmptyMetricFindValueObservable();
+    }
+    return from(
+      this.datasource.metricFindQuery(variable.state.query, __spreadProps(__spreadValues({}, request), {
+        variable: {
+          name: variable.state.name,
+          type: variable.state.type
+        },
+        searchFilter
+      }))
+    ).pipe(
+      mergeMap((values) => {
+        if (!values || !values.length) {
+          return getEmptyMetricFindValueObservable();
+        }
+        const series = values;
+        return of({ series, state: LoadingState.Done, timeRange: request.range });
+      })
+    );
+  }
+}
+class CustomQueryRunner {
+  constructor(datasource, _runRequest = getRunRequest()) {
+    this.datasource = datasource;
+    this._runRequest = _runRequest;
+  }
+  getTarget(variable) {
+    if (hasCustomVariableSupport(this.datasource)) {
+      return variable.state.query;
+    }
+    throw new Error("Couldn't create a target with supplied arguments.");
+  }
+  runRequest(_, request) {
+    if (!hasCustomVariableSupport(this.datasource)) {
+      return getEmptyMetricFindValueObservable();
+    }
+    if (!this.datasource.variables.query) {
+      return this._runRequest(this.datasource, request);
+    }
+    return this._runRequest(this.datasource, request, this.datasource.variables.query.bind(this.datasource.variables));
+  }
+}
+function getEmptyMetricFindValueObservable() {
+  return of({ state: LoadingState.Done, series: [], timeRange: getDefaultTimeRange() });
+}
+function createQueryVariableRunnerFactory(datasource) {
+  if (hasStandardVariableSupport(datasource)) {
+    return new StandardQueryRunner(datasource, getRunRequest());
+  }
+  if (hasLegacyVariableSupport(datasource)) {
+    return new LegacyQueryRunner(datasource);
+  }
+  if (hasCustomVariableSupport(datasource)) {
+    return new CustomQueryRunner(datasource);
+  }
+  throw new Error(`Couldn't create a query runner for datasource ${datasource.type}`);
+}
+let createQueryVariableRunner = createQueryVariableRunnerFactory;
+function ensureVariableQueryModelIsADataQuery(variable) {
+  var _a;
+  const query = (_a = variable.state.query) != null ? _a : "";
+  if (typeof query === "string") {
+    return { query, refId: `variable-${variable.state.name}` };
+  }
+  if (query.refId == null) {
+    return __spreadProps(__spreadValues({}, query), { refId: `variable-${variable.state.name}` });
+  }
+  return variable.state.query;
+}
+
+export { createQueryVariableRunner };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createQueryVariableRunner.js","sources":["../../../../../../src/variables/variants/query/createQueryVariableRunner.ts"],"sourcesContent":["import { from, mergeMap, Observable, of } from 'rxjs';\n\nimport {\n  DataQueryRequest,\n  DataSourceApi,\n  getDefaultTimeRange,\n  LoadingState,\n  PanelData,\n  StandardVariableQuery,\n} from '@grafana/data';\nimport { getRunRequest } from '@grafana/runtime';\n\nimport { hasCustomVariableSupport, hasLegacyVariableSupport, hasStandardVariableSupport } from './guards';\n\nimport { QueryVariable } from './QueryVariable';\nimport { DataQuery } from '@grafana/schema';\n\nexport interface RunnerArgs {\n  searchFilter?: string;\n  variable: QueryVariable;\n}\n\nexport interface QueryRunner {\n  getTarget: (variable: QueryVariable) => DataQuery | string;\n  runRequest: (args: RunnerArgs, request: DataQueryRequest) => Observable<PanelData>;\n}\n\nclass StandardQueryRunner implements QueryRunner {\n  public constructor(private datasource: DataSourceApi, private _runRequest = getRunRequest()) {}\n\n  public getTarget(variable: QueryVariable) {\n    if (hasStandardVariableSupport(this.datasource)) {\n      return this.datasource.variables.toDataQuery(ensureVariableQueryModelIsADataQuery(variable));\n    }\n\n    throw new Error(\"Couldn't create a target with supplied arguments.\");\n  }\n\n  public runRequest(_: RunnerArgs, request: DataQueryRequest) {\n    if (!hasStandardVariableSupport(this.datasource)) {\n      return getEmptyMetricFindValueObservable();\n    }\n\n    if (!this.datasource.variables.query) {\n      return this._runRequest(this.datasource, request);\n    }\n\n    return this._runRequest(this.datasource, request, this.datasource.variables.query.bind(this.datasource.variables));\n  }\n}\n\nclass LegacyQueryRunner implements QueryRunner {\n  public constructor(private datasource: DataSourceApi) {}\n\n  public getTarget(variable: QueryVariable) {\n    if (hasLegacyVariableSupport(this.datasource)) {\n      return variable.state.query;\n    }\n\n    throw new Error(\"Couldn't create a target with supplied arguments.\");\n  }\n\n  public runRequest({ variable, searchFilter }: RunnerArgs, request: DataQueryRequest) {\n    if (!hasLegacyVariableSupport(this.datasource)) {\n      return getEmptyMetricFindValueObservable();\n    }\n\n    return from(\n      this.datasource.metricFindQuery(variable.state.query, {\n        ...request,\n        // variable is used by SQL common data source\n        variable: {\n          name: variable.state.name,\n          type: variable.state.type,\n        },\n        searchFilter,\n      })\n    ).pipe(\n      mergeMap((values) => {\n        if (!values || !values.length) {\n          return getEmptyMetricFindValueObservable();\n        }\n\n        const series: any = values;\n        return of({ series, state: LoadingState.Done, timeRange: request.range });\n      })\n    );\n  }\n}\n\nclass CustomQueryRunner implements QueryRunner {\n  public constructor(private datasource: DataSourceApi, private _runRequest = getRunRequest()) {}\n\n  public getTarget(variable: QueryVariable) {\n    if (hasCustomVariableSupport(this.datasource)) {\n      return variable.state.query;\n    }\n\n    throw new Error(\"Couldn't create a target with supplied arguments.\");\n  }\n\n  public runRequest(_: RunnerArgs, request: DataQueryRequest) {\n    if (!hasCustomVariableSupport(this.datasource)) {\n      return getEmptyMetricFindValueObservable();\n    }\n\n    if (!this.datasource.variables.query) {\n      return this._runRequest(this.datasource, request);\n    }\n    return this._runRequest(this.datasource, request, this.datasource.variables.query.bind(this.datasource.variables));\n  }\n}\n\nfunction getEmptyMetricFindValueObservable(): Observable<PanelData> {\n  return of({ state: LoadingState.Done, series: [], timeRange: getDefaultTimeRange() });\n}\n\nfunction createQueryVariableRunnerFactory(datasource: DataSourceApi): QueryRunner {\n  if (hasStandardVariableSupport(datasource)) {\n    return new StandardQueryRunner(datasource, getRunRequest());\n  }\n\n  if (hasLegacyVariableSupport(datasource)) {\n    return new LegacyQueryRunner(datasource);\n  }\n\n  if (hasCustomVariableSupport(datasource)) {\n    return new CustomQueryRunner(datasource);\n  }\n\n  throw new Error(`Couldn't create a query runner for datasource ${datasource.type}`);\n}\n\nexport let createQueryVariableRunner = createQueryVariableRunnerFactory;\n\n/**\n * Use only in tests\n */\nexport function setCreateQueryVariableRunnerFactory(fn: (datasource: DataSourceApi) => QueryRunner) {\n  createQueryVariableRunner = fn;\n}\n\n/**\n * Fixes old legacy query string models and adds refId if missing\n */\nfunction ensureVariableQueryModelIsADataQuery(variable: QueryVariable): StandardVariableQuery {\n  const query = variable.state.query ?? '';\n\n  // Turn into query object if it's just a string\n  if (typeof query === 'string') {\n    return { query, refId: `variable-${variable.state.name}` };\n  }\n\n  // Add potentially missing refId\n  if (query.refId == null) {\n    return { ...query, refId: `variable-${variable.state.name}` } as StandardVariableQuery;\n  }\n\n  return variable.state.query as StandardVariableQuery;\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/src/variables/variants/query/guards.js

@@ -0,0 +1,28 @@
+import { VariableSupportType } from '@grafana/data';
+
+const hasLegacyVariableSupport = (datasource) => {
+  return Boolean(datasource.metricFindQuery) && !Boolean(datasource.variables);
+};
+const hasStandardVariableSupport = (datasource) => {
+  if (!datasource.variables) {
+    return false;
+  }
+  if (datasource.variables.getType() !== VariableSupportType.Standard) {
+    return false;
+  }
+  const variableSupport = datasource.variables;
+  return "toDataQuery" in variableSupport && Boolean(variableSupport.toDataQuery);
+};
+const hasCustomVariableSupport = (datasource) => {
+  if (!datasource.variables) {
+    return false;
+  }
+  if (datasource.variables.getType() !== VariableSupportType.Custom) {
+    return false;
+  }
+  const variableSupport = datasource.variables;
+  return "query" in variableSupport && "editor" in variableSupport && Boolean(variableSupport.query) && Boolean(variableSupport.editor);
+};
+
+export { hasCustomVariableSupport, hasLegacyVariableSupport, hasStandardVariableSupport };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/variables/variants/query/toMetricFindValues.js

@@ -0,0 +1,96 @@
+import { getProcessedDataFrames, getFieldDisplayName, FieldType, isDataFrame } from '@grafana/data';
+import { map } from 'rxjs';
+
+function toMetricFindValues() {
+  return (source) => source.pipe(
+    map((panelData) => {
+      const frames = panelData.series;
+      if (!frames || !frames.length) {
+        return [];
+      }
+      if (areMetricFindValues(frames)) {
+        return frames;
+      }
+      if (frames[0].fields.length === 0) {
+        return [];
+      }
+      const processedDataFrames = getProcessedDataFrames(frames);
+      const metrics = [];
+      let valueIndex = -1;
+      let textIndex = -1;
+      let stringIndex = -1;
+      let expandableIndex = -1;
+      for (const frame of processedDataFrames) {
+        for (let index = 0; index < frame.fields.length; index++) {
+          const field = frame.fields[index];
+          const fieldName = getFieldDisplayName(field, frame, frames).toLowerCase();
+          if (field.type === FieldType.string && stringIndex === -1) {
+            stringIndex = index;
+          }
+          if (fieldName === "text" && field.type === FieldType.string && textIndex === -1) {
+            textIndex = index;
+          }
+          if (fieldName === "value" && field.type === FieldType.string && valueIndex === -1) {
+            valueIndex = index;
+          }
+          if (fieldName === "expandable" && (field.type === FieldType.boolean || field.type === FieldType.number) && expandableIndex === -1) {
+            expandableIndex = index;
+          }
+        }
+      }
+      if (stringIndex === -1) {
+        throw new Error("Couldn't find any field of type string in the results.");
+      }
+      for (const frame of frames) {
+        for (let index = 0; index < frame.length; index++) {
+          const expandable = expandableIndex !== -1 ? frame.fields[expandableIndex].values.get(index) : void 0;
+          const string = frame.fields[stringIndex].values.get(index);
+          const text = textIndex !== -1 ? frame.fields[textIndex].values.get(index) : "";
+          const value = valueIndex !== -1 ? frame.fields[valueIndex].values.get(index) : "";
+          if (valueIndex === -1 && textIndex === -1) {
+            metrics.push({ text: string, value: string, expandable });
+            continue;
+          }
+          if (valueIndex === -1 && textIndex !== -1) {
+            metrics.push({ text, value: text, expandable });
+            continue;
+          }
+          if (valueIndex !== -1 && textIndex === -1) {
+            metrics.push({ text: value, value, expandable });
+            continue;
+          }
+          metrics.push({ text, value, expandable });
+        }
+      }
+      return metrics;
+    })
+  );
+}
+function areMetricFindValues(data) {
+  if (!data) {
+    return false;
+  }
+  if (!data.length) {
+    return true;
+  }
+  const firstValue = data[0];
+  if (isDataFrame(firstValue)) {
+    return false;
+  }
+  for (const firstValueKey in firstValue) {
+    if (!firstValue.hasOwnProperty(firstValueKey)) {
+      continue;
+    }
+    if (firstValue[firstValueKey] !== null && typeof firstValue[firstValueKey] !== "string" && typeof firstValue[firstValueKey] !== "number") {
+      continue;
+    }
+    const key = firstValueKey.toLowerCase();
+    if (key === "text" || key === "value") {
+      return true;
+    }
+  }
+  return false;
+}
+
+export { toMetricFindValues };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"toMetricFindValues.js","sources":["../../../../../../src/variables/variants/query/toMetricFindValues.ts"],"sourcesContent":["import {\n  FieldType,\n  getFieldDisplayName,\n  isDataFrame,\n  MetricFindValue,\n  PanelData,\n  getProcessedDataFrames,\n} from '@grafana/data';\nimport { map, OperatorFunction } from 'rxjs';\n\nexport function toMetricFindValues(): OperatorFunction<PanelData, MetricFindValue[]> {\n  return (source) =>\n    source.pipe(\n      map((panelData) => {\n        const frames = panelData.series;\n        if (!frames || !frames.length) {\n          return [];\n        }\n\n        if (areMetricFindValues(frames)) {\n          return frames;\n        }\n\n        if (frames[0].fields.length === 0) {\n          return [];\n        }\n\n        const processedDataFrames = getProcessedDataFrames(frames);\n        const metrics: MetricFindValue[] = [];\n\n        let valueIndex = -1;\n        let textIndex = -1;\n        let stringIndex = -1;\n        let expandableIndex = -1;\n\n        for (const frame of processedDataFrames) {\n          for (let index = 0; index < frame.fields.length; index++) {\n            const field = frame.fields[index];\n            const fieldName = getFieldDisplayName(field, frame, frames).toLowerCase();\n\n            if (field.type === FieldType.string && stringIndex === -1) {\n              stringIndex = index;\n            }\n\n            if (fieldName === 'text' && field.type === FieldType.string && textIndex === -1) {\n              textIndex = index;\n            }\n\n            if (fieldName === 'value' && field.type === FieldType.string && valueIndex === -1) {\n              valueIndex = index;\n            }\n\n            if (\n              fieldName === 'expandable' &&\n              (field.type === FieldType.boolean || field.type === FieldType.number) &&\n              expandableIndex === -1\n            ) {\n              expandableIndex = index;\n            }\n          }\n        }\n\n        if (stringIndex === -1) {\n          throw new Error(\"Couldn't find any field of type string in the results.\");\n        }\n\n        for (const frame of frames) {\n          for (let index = 0; index < frame.length; index++) {\n            const expandable = expandableIndex !== -1 ? frame.fields[expandableIndex].values.get(index) : undefined;\n            const string = frame.fields[stringIndex].values.get(index);\n            const text = textIndex !== -1 ? frame.fields[textIndex].values.get(index) : '';\n            const value = valueIndex !== -1 ? frame.fields[valueIndex].values.get(index) : '';\n\n            if (valueIndex === -1 && textIndex === -1) {\n              metrics.push({ text: string, value: string, expandable });\n              continue;\n            }\n\n            if (valueIndex === -1 && textIndex !== -1) {\n              metrics.push({ text, value: text, expandable });\n              continue;\n            }\n\n            if (valueIndex !== -1 && textIndex === -1) {\n              metrics.push({ text: value, value, expandable });\n              continue;\n            }\n\n            metrics.push({ text, value, expandable });\n          }\n        }\n\n        return metrics;\n      })\n    );\n}\n\nfunction areMetricFindValues(data: any[]): data is MetricFindValue[] {\n  if (!data) {\n    return false;\n  }\n\n  if (!data.length) {\n    return true;\n  }\n\n  const firstValue: any = data[0];\n\n  if (isDataFrame(firstValue)) {\n    return false;\n  }\n\n  for (const firstValueKey in firstValue) {\n    if (!firstValue.hasOwnProperty(firstValueKey)) {\n      continue;\n    }\n\n    if (\n      firstValue[firstValueKey] !== null &&\n      typeof firstValue[firstValueKey] !== 'string' &&\n      typeof firstValue[firstValueKey] !== 'number'\n    ) {\n      continue;\n    }\n\n    const key = firstValueKey.toLowerCase();\n\n    if (key === 'text' || key === 'value') {\n      return true;\n    }\n  }\n\n  return false;\n}\n"],"names":[],"mappings":";;;AAUO,SAAS,kBAAqE,GAAA;AACnF,EAAO,OAAA,CAAC,WACN,MAAO,CAAA,IAAA;AAAA,IACL,GAAA,CAAI,CAAC,SAAc,KAAA;AACjB,MAAA,MAAM,SAAS,SAAU,CAAA,MAAA,CAAA;AACzB,MAAA,IAAI,CAAC,MAAA,IAAU,CAAC,MAAA,CAAO,MAAQ,EAAA;AAC7B,QAAA,OAAO,EAAC,CAAA;AAAA,OACV;AAEA,MAAI,IAAA,mBAAA,CAAoB,MAAM,CAAG,EAAA;AAC/B,QAAO,OAAA,MAAA,CAAA;AAAA,OACT;AAEA,MAAA,IAAI,MAAO,CAAA,CAAA,CAAA,CAAG,MAAO,CAAA,MAAA,KAAW,CAAG,EAAA;AACjC,QAAA,OAAO,EAAC,CAAA;AAAA,OACV;AAEA,MAAM,MAAA,mBAAA,GAAsB,uBAAuB,MAAM,CAAA,CAAA;AACzD,MAAA,MAAM,UAA6B,EAAC,CAAA;AAEpC,MAAA,IAAI,UAAa,GAAA,CAAA,CAAA,CAAA;AACjB,MAAA,IAAI,SAAY,GAAA,CAAA,CAAA,CAAA;AAChB,MAAA,IAAI,WAAc,GAAA,CAAA,CAAA,CAAA;AAClB,MAAA,IAAI,eAAkB,GAAA,CAAA,CAAA,CAAA;AAEtB,MAAA,KAAA,MAAW,SAAS,mBAAqB,EAAA;AACvC,QAAA,KAAA,IAAS,QAAQ,CAAG,EAAA,KAAA,GAAQ,KAAM,CAAA,MAAA,CAAO,QAAQ,KAAS,EAAA,EAAA;AACxD,UAAM,MAAA,KAAA,GAAQ,MAAM,MAAO,CAAA,KAAA,CAAA,CAAA;AAC3B,UAAA,MAAM,YAAY,mBAAoB,CAAA,KAAA,EAAO,KAAO,EAAA,MAAM,EAAE,WAAY,EAAA,CAAA;AAExE,UAAA,IAAI,KAAM,CAAA,IAAA,KAAS,SAAU,CAAA,MAAA,IAAU,gBAAgB,CAAI,CAAA,EAAA;AACzD,YAAc,WAAA,GAAA,KAAA,CAAA;AAAA,WAChB;AAEA,UAAA,IAAI,cAAc,MAAU,IAAA,KAAA,CAAM,SAAS,SAAU,CAAA,MAAA,IAAU,cAAc,CAAI,CAAA,EAAA;AAC/E,YAAY,SAAA,GAAA,KAAA,CAAA;AAAA,WACd;AAEA,UAAA,IAAI,cAAc,OAAW,IAAA,KAAA,CAAM,SAAS,SAAU,CAAA,MAAA,IAAU,eAAe,CAAI,CAAA,EAAA;AACjF,YAAa,UAAA,GAAA,KAAA,CAAA;AAAA,WACf;AAEA,UACE,IAAA,SAAA,KAAc,YACb,KAAA,KAAA,CAAM,IAAS,KAAA,SAAA,CAAU,OAAW,IAAA,KAAA,CAAM,IAAS,KAAA,SAAA,CAAU,MAC9D,CAAA,IAAA,eAAA,KAAoB,CACpB,CAAA,EAAA;AACA,YAAkB,eAAA,GAAA,KAAA,CAAA;AAAA,WACpB;AAAA,SACF;AAAA,OACF;AAEA,MAAA,IAAI,gBAAgB,CAAI,CAAA,EAAA;AACtB,QAAM,MAAA,IAAI,MAAM,wDAAwD,CAAA,CAAA;AAAA,OAC1E;AAEA,MAAA,KAAA,MAAW,SAAS,MAAQ,EAAA;AAC1B,QAAA,KAAA,IAAS,KAAQ,GAAA,CAAA,EAAG,KAAQ,GAAA,KAAA,CAAM,QAAQ,KAAS,EAAA,EAAA;AACjD,UAAM,MAAA,UAAA,GAAa,oBAAoB,CAAK,CAAA,GAAA,KAAA,CAAM,OAAO,eAAiB,CAAA,CAAA,MAAA,CAAO,GAAI,CAAA,KAAK,CAAI,GAAA,KAAA,CAAA,CAAA;AAC9F,UAAA,MAAM,SAAS,KAAM,CAAA,MAAA,CAAO,WAAa,CAAA,CAAA,MAAA,CAAO,IAAI,KAAK,CAAA,CAAA;AACzD,UAAM,MAAA,IAAA,GAAO,cAAc,CAAK,CAAA,GAAA,KAAA,CAAM,OAAO,SAAW,CAAA,CAAA,MAAA,CAAO,GAAI,CAAA,KAAK,CAAI,GAAA,EAAA,CAAA;AAC5E,UAAM,MAAA,KAAA,GAAQ,eAAe,CAAK,CAAA,GAAA,KAAA,CAAM,OAAO,UAAY,CAAA,CAAA,MAAA,CAAO,GAAI,CAAA,KAAK,CAAI,GAAA,EAAA,CAAA;AAE/E,UAAI,IAAA,UAAA,KAAe,CAAM,CAAA,IAAA,SAAA,KAAc,CAAI,CAAA,EAAA;AACzC,YAAA,OAAA,CAAQ,KAAK,EAAE,IAAA,EAAM,QAAQ,KAAO,EAAA,MAAA,EAAQ,YAAY,CAAA,CAAA;AACxD,YAAA,SAAA;AAAA,WACF;AAEA,UAAI,IAAA,UAAA,KAAe,CAAM,CAAA,IAAA,SAAA,KAAc,CAAI,CAAA,EAAA;AACzC,YAAA,OAAA,CAAQ,KAAK,EAAE,IAAA,EAAM,KAAO,EAAA,IAAA,EAAM,YAAY,CAAA,CAAA;AAC9C,YAAA,SAAA;AAAA,WACF;AAEA,UAAI,IAAA,UAAA,KAAe,CAAM,CAAA,IAAA,SAAA,KAAc,CAAI,CAAA,EAAA;AACzC,YAAA,OAAA,CAAQ,KAAK,EAAE,IAAA,EAAM,KAAO,EAAA,KAAA,EAAO,YAAY,CAAA,CAAA;AAC/C,YAAA,SAAA;AAAA,WACF;AAEA,UAAA,OAAA,CAAQ,IAAK,CAAA,EAAE,IAAM,EAAA,KAAA,EAAO,YAAY,CAAA,CAAA;AAAA,SAC1C;AAAA,OACF;AAEA,MAAO,OAAA,OAAA,CAAA;AAAA,KACR,CAAA;AAAA,GACH,CAAA;AACJ,CAAA;AAEA,SAAS,oBAAoB,IAAwC,EAAA;AACnE,EAAA,IAAI,CAAC,IAAM,EAAA;AACT,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAEA,EAAI,IAAA,CAAC,KAAK,MAAQ,EAAA;AAChB,IAAO,OAAA,IAAA,CAAA;AAAA,GACT;AAEA,EAAA,MAAM,aAAkB,IAAK,CAAA,CAAA,CAAA,CAAA;AAE7B,EAAI,IAAA,WAAA,CAAY,UAAU,CAAG,EAAA;AAC3B,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAEA,EAAA,KAAA,MAAW,iBAAiB,UAAY,EAAA;AACtC,IAAA,IAAI,CAAC,UAAA,CAAW,cAAe,CAAA,aAAa,CAAG,EAAA;AAC7C,MAAA,SAAA;AAAA,KACF;AAEA,IACE,IAAA,UAAA,CAAW,aAAmB,CAAA,KAAA,IAAA,IAC9B,OAAO,UAAA,CAAW,mBAAmB,QACrC,IAAA,OAAO,UAAW,CAAA,aAAA,CAAA,KAAmB,QACrC,EAAA;AACA,MAAA,SAAA;AAAA,KACF;AAEA,IAAM,MAAA,GAAA,GAAM,cAAc,WAAY,EAAA,CAAA;AAEtC,IAAI,IAAA,GAAA,KAAQ,MAAU,IAAA,GAAA,KAAQ,OAAS,EAAA;AACrC,MAAO,OAAA,IAAA,CAAA;AAAA,KACT;AAAA,GACF;AAEA,EAAO,OAAA,KAAA,CAAA;AACT;;;;"}

package/dist/esm/src/variables/variants/query/utils.js

@@ -0,0 +1,124 @@
+import { isNumber, uniqBy, sortBy, toLower } from 'lodash';
+import { stringToJsRegex, VariableSort } from '@grafana/data';
+
+function metricNamesToVariableValues(variableRegEx, sort, metricNames) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  let regex;
+  let options = [];
+  if (variableRegEx) {
+    regex = stringToJsRegex(variableRegEx);
+  }
+  for (let i = 0; i < metricNames.length; i++) {
+    const item = metricNames[i];
+    let text = (_b = (_a = item.text) != null ? _a : item.value) != null ? _b : "";
+    let value = (_d = (_c = item.value) != null ? _c : item.text) != null ? _d : "";
+    if (isNumber(value)) {
+      value = value.toString();
+    }
+    if (isNumber(text)) {
+      text = text.toString();
+    }
+    if (regex) {
+      const matches = getAllMatches(value, regex);
+      if (!matches.length) {
+        continue;
+      }
+      const valueGroup = matches.find((m) => m.groups && m.groups.value);
+      const textGroup = matches.find((m) => m.groups && m.groups.text);
+      const firstMatch = matches.find((m) => m.length > 1);
+      const manyMatches = matches.length > 1 && firstMatch;
+      if (valueGroup || textGroup) {
+        value = (_g = (_e = valueGroup == null ? void 0 : valueGroup.groups) == null ? void 0 : _e.value) != null ? _g : (_f = textGroup == null ? void 0 : textGroup.groups) == null ? void 0 : _f.text;
+        text = (_j = (_h = textGroup == null ? void 0 : textGroup.groups) == null ? void 0 : _h.text) != null ? _j : (_i = valueGroup == null ? void 0 : valueGroup.groups) == null ? void 0 : _i.value;
+      } else if (manyMatches) {
+        for (let j = 0; j < matches.length; j++) {
+          const match = matches[j];
+          options.push({ label: match[1], value: match[1] });
+        }
+        continue;
+      } else if (firstMatch) {
+        text = firstMatch[1];
+        value = firstMatch[1];
+      }
+    }
+    options.push({ label: text, value });
+  }
+  options = uniqBy(options, "value");
+  return sortVariableValues(options, sort);
+}
+const getAllMatches = (str, regex) => {
+  const results = [];
+  let matches = null;
+  regex.lastIndex = 0;
+  do {
+    matches = regex.exec(str);
+    if (matches) {
+      results.push(matches);
+    }
+  } while (regex.global && matches && matches[0] !== "" && matches[0] !== void 0);
+  return results;
+};
+const sortVariableValues = (options, sortOrder) => {
+  if (sortOrder === VariableSort.disabled) {
+    return options;
+  }
+  const sortByNumeric = (opt) => {
+    if (!opt.text) {
+      return -1;
+    }
+    const matches = opt.text.match(/.*?(\d+).*/);
+    if (!matches || matches.length < 2) {
+      return -1;
+    } else {
+      return parseInt(matches[1], 10);
+    }
+  };
+  const sortByNaturalSort = (options2) => {
+    return options2.sort((a, b) => {
+      if (!a.text) {
+        return -1;
+      }
+      if (!b.text) {
+        return 1;
+      }
+      return a.text.localeCompare(b.text, void 0, { numeric: true });
+    });
+  };
+  switch (sortOrder) {
+    case VariableSort.alphabeticalAsc:
+      options = sortBy(options, "label");
+      break;
+    case VariableSort.alphabeticalDesc:
+      options = sortBy(options, "label").reverse();
+      break;
+    case VariableSort.numericalAsc:
+      options = sortBy(options, sortByNumeric);
+      break;
+    case VariableSort.numericalDesc:
+      options = sortBy(options, sortByNumeric);
+      options = options.reverse();
+      break;
+    case VariableSort.alphabeticalCaseInsensitiveAsc:
+      options = sortBy(options, (opt) => {
+        return toLower(opt.label);
+      });
+      break;
+    case VariableSort.alphabeticalCaseInsensitiveDesc:
+      options = sortBy(options, (opt) => {
+        return toLower(opt.label);
+      });
+      options = options.reverse();
+      break;
+    case (VariableSort.naturalAsc || 7):
+      options = sortByNaturalSort(options);
+      break;
+    case (VariableSort.naturalDesc || 8):
+      options = sortByNaturalSort(options);
+      options = options.reverse();
+      break;
+  }
+  return options;
+};
+
+export { metricNamesToVariableValues, sortVariableValues };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"utils.js","sources":["../../../../../../src/variables/variants/query/utils.ts"],"sourcesContent":["import { isNumber, sortBy, toLower, uniqBy } from 'lodash';\n\nimport { stringToJsRegex, VariableSort } from '@grafana/data';\n\nimport { VariableValueOption } from '../../types';\n\nexport function metricNamesToVariableValues(variableRegEx: string, sort: VariableSort, metricNames: any[]) {\n  let regex;\n  let options: VariableValueOption[] = [];\n\n  if (variableRegEx) {\n    regex = stringToJsRegex(variableRegEx);\n  }\n\n  for (let i = 0; i < metricNames.length; i++) {\n    const item = metricNames[i];\n    let text = item.text ?? item.value ?? '';\n    let value = item.value ?? item.text ?? '';\n\n    if (isNumber(value)) {\n      value = value.toString();\n    }\n\n    if (isNumber(text)) {\n      text = text.toString();\n    }\n\n    if (regex) {\n      const matches = getAllMatches(value, regex);\n      if (!matches.length) {\n        continue;\n      }\n\n      const valueGroup = matches.find((m) => m.groups && m.groups.value);\n      const textGroup = matches.find((m) => m.groups && m.groups.text);\n      const firstMatch = matches.find((m) => m.length > 1);\n      const manyMatches = matches.length > 1 && firstMatch;\n\n      if (valueGroup || textGroup) {\n        value = valueGroup?.groups?.value ?? textGroup?.groups?.text;\n        text = textGroup?.groups?.text ?? valueGroup?.groups?.value;\n      } else if (manyMatches) {\n        for (let j = 0; j < matches.length; j++) {\n          const match = matches[j];\n          options.push({ label: match[1], value: match[1] });\n        }\n        continue;\n      } else if (firstMatch) {\n        text = firstMatch[1];\n        value = firstMatch[1];\n      }\n    }\n\n    options.push({ label: text, value: value });\n  }\n\n  options = uniqBy(options, 'value');\n  return sortVariableValues(options, sort);\n}\n\nconst getAllMatches = (str: string, regex: RegExp): RegExpExecArray[] => {\n  const results: RegExpExecArray[] = [];\n  let matches = null;\n\n  regex.lastIndex = 0;\n\n  do {\n    matches = regex.exec(str);\n    if (matches) {\n      results.push(matches);\n    }\n  } while (regex.global && matches && matches[0] !== '' && matches[0] !== undefined);\n\n  return results;\n};\n\nexport const sortVariableValues = (options: any[], sortOrder: VariableSort) => {\n  if (sortOrder === VariableSort.disabled) {\n    return options;\n  }\n\n  // @ts-ignore\n  const sortByNumeric = (opt) => {\n    if (!opt.text) {\n      return -1;\n    }\n    const matches = opt.text.match(/.*?(\\d+).*/);\n    if (!matches || matches.length < 2) {\n      return -1;\n    } else {\n      return parseInt(matches[1], 10);\n    }\n  };\n\n  // @ts-ignore\n  const sortByNaturalSort = (options) => {\n    //@ts-ignore\n    return options.sort((a, b) => {\n      if (!a.text) {\n        return -1;\n      }\n\n      if (!b.text) {\n        return 1;\n      }\n\n      return a.text.localeCompare(b.text, undefined, { numeric: true });\n    });\n  };\n\n  switch (sortOrder) {\n    case VariableSort.alphabeticalAsc:\n      options = sortBy(options, 'label');\n      break;\n    case VariableSort.alphabeticalDesc:\n      options = sortBy(options, 'label').reverse();\n      break;\n    case VariableSort.numericalAsc:\n      options = sortBy(options, sortByNumeric);\n      break;\n    case VariableSort.numericalDesc:\n      options = sortBy(options, sortByNumeric);\n      options = options.reverse();\n      break;\n    case VariableSort.alphabeticalCaseInsensitiveAsc:\n      options = sortBy(options, (opt) => {\n        return toLower(opt.label);\n      });\n      break;\n    case VariableSort.alphabeticalCaseInsensitiveDesc:\n      options = sortBy(options, (opt) => {\n        return toLower(opt.label);\n      });\n      options = options.reverse();\n      break;\n    case VariableSort.naturalAsc || 7:\n      // Sort by natural sort\n      options = sortByNaturalSort(options);\n      break;\n    case VariableSort.naturalDesc || 8:\n      options = sortByNaturalSort(options);\n      options = options.reverse();\n      break;\n    default:\n      break;\n  }\n  return options;\n};\n"],"names":["options"],"mappings":"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"}