@grafana/scenes 6.7.0 → 6.8.0

package/dist/esm/dist/esm/variables/groupby/GroupByVariable.js

@@ -0,0 +1,259 @@
+import React, { useMemo, useState, useEffect } from 'react';
+import { allActiveGroupByVariables } from './findActiveGroupByVariablesByUid.js';
+import { sceneGraph } from '../../core/sceneGraph/index.js';
+import { MultiValueVariable } from '../variants/MultiValueVariable.js';
+import { lastValueFrom, map, of, from, mergeMap, tap, take } from 'rxjs';
+import { getDataSource } from '../../utils/getDataSource.js';
+import { MultiSelect } from '@grafana/ui';
+import { isArray } from 'lodash';
+import { handleOptionGroups, dataFromResponse, getQueriesForVariables, responseHasError } from '../utils.js';
+import { OptionWithCheckbox } from '../components/VariableValueSelect.js';
+import { GroupByVariableUrlSyncHandler } from './GroupByVariableUrlSyncHandler.js';
+import { getOptionSearcher } from '../components/getOptionSearcher.js';
+import { getEnrichedFiltersRequest } from '../getEnrichedFiltersRequest.js';
+import { wrapInSafeSerializableSceneObject } from '../../utils/wrapInSafeSerializableSceneObject.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 GroupByVariable extends MultiValueVariable {
+  constructor(initialState) {
+    super(__spreadProps(__spreadValues({
+      isMulti: true,
+      name: "",
+      value: [],
+      text: [],
+      options: [],
+      datasource: null,
+      baseFilters: [],
+      applyMode: "auto",
+      layout: "horizontal",
+      type: "groupby"
+    }, initialState), {
+      noValueOnClear: true
+    }));
+    this.isLazy = true;
+    this._urlSync = new GroupByVariableUrlSyncHandler(this);
+    this._getKeys = async (ds) => {
+      var _a, _b, _c;
+      const override = await ((_b = (_a = this.state).getTagKeysProvider) == null ? void 0 : _b.call(_a, this, null));
+      if (override && override.replace) {
+        return override.values;
+      }
+      if (this.state.defaultOptions) {
+        return this.state.defaultOptions.concat(dataFromResponse((_c = override == null ? void 0 : override.values) != null ? _c : []));
+      }
+      if (!ds.getTagKeys) {
+        return [];
+      }
+      const queries = getQueriesForVariables(this);
+      const otherFilters = this.state.baseFilters || [];
+      const timeRange = sceneGraph.getTimeRange(this).state.value;
+      const response = await ds.getTagKeys(__spreadValues({
+        filters: otherFilters,
+        queries,
+        timeRange
+      }, getEnrichedFiltersRequest(this)));
+      if (responseHasError(response)) {
+        this.setState({ error: response.error.message });
+      }
+      let keys = dataFromResponse(response);
+      if (override) {
+        keys = keys.concat(dataFromResponse(override.values));
+      }
+      const tagKeyRegexFilter = this.state.tagKeyRegexFilter;
+      if (tagKeyRegexFilter) {
+        keys = keys.filter((f) => f.text.match(tagKeyRegexFilter));
+      }
+      return keys;
+    };
+    this.addActivationHandler(() => {
+      allActiveGroupByVariables.add(this);
+      return () => allActiveGroupByVariables.delete(this);
+    });
+  }
+  validateAndUpdate() {
+    return this.getValueOptions({}).pipe(
+      map((options) => {
+        this._updateValueGivenNewOptions(options);
+        return {};
+      })
+    );
+  }
+  _updateValueGivenNewOptions(options) {
+    const { value: currentValue, text: currentText } = this.state;
+    const stateUpdate = {
+      options,
+      loading: false,
+      value: currentValue != null ? currentValue : [],
+      text: currentText != null ? currentText : []
+    };
+    this.setState(stateUpdate);
+  }
+  getValueOptions(args) {
+    if (this.state.defaultOptions) {
+      return of(
+        this.state.defaultOptions.map((o) => ({
+          label: o.text,
+          value: String(o.value),
+          group: o.group
+        }))
+      );
+    }
+    this.setState({ loading: true, error: null });
+    return from(
+      getDataSource(this.state.datasource, {
+        __sceneObject: wrapInSafeSerializableSceneObject(this)
+      })
+    ).pipe(
+      mergeMap((ds) => {
+        return from(this._getKeys(ds)).pipe(
+          tap((response) => {
+            if (responseHasError(response)) {
+              this.setState({ error: response.error.message });
+            }
+          }),
+          map((response) => dataFromResponse(response)),
+          take(1),
+          mergeMap((data) => {
+            const a = data.map((i) => {
+              return {
+                label: i.text,
+                value: i.value ? String(i.value) : i.text,
+                group: i.group
+              };
+            });
+            return of(a);
+          })
+        );
+      })
+    );
+  }
+  getDefaultMultiState(options) {
+    return { value: [], text: [] };
+  }
+}
+GroupByVariable.Component = GroupByVariableRenderer;
+function GroupByVariableRenderer({ model }) {
+  const {
+    value,
+    text,
+    key,
+    maxVisibleValues,
+    noValueOnClear,
+    options,
+    includeAll,
+    allowCustomValue = true
+  } = model.useState();
+  const values = useMemo(() => {
+    const arrayValue = isArray(value) ? value : [value];
+    const arrayText = isArray(text) ? text : [text];
+    return arrayValue.map((value2, idx) => {
+      var _a;
+      return {
+        value: value2,
+        label: String((_a = arrayText[idx]) != null ? _a : value2)
+      };
+    });
+  }, [value, text]);
+  const [isFetchingOptions, setIsFetchingOptions] = useState(false);
+  const [isOptionsOpen, setIsOptionsOpen] = useState(false);
+  const [inputValue, setInputValue] = useState("");
+  const [uncommittedValue, setUncommittedValue] = useState(values);
+  const optionSearcher = useMemo(() => getOptionSearcher(options, includeAll), [options, includeAll]);
+  useEffect(() => {
+    setUncommittedValue(values);
+  }, [values]);
+  const onInputChange = (value2, { action }) => {
+    if (action === "input-change") {
+      setInputValue(value2);
+      if (model.onSearchChange) {
+        model.onSearchChange(value2);
+      }
+      return value2;
+    }
+    if (action === "input-blur") {
+      setInputValue("");
+      return "";
+    }
+    return inputValue;
+  };
+  const filteredOptions = useMemo(
+    () => handleOptionGroups(optionSearcher(inputValue).map(toSelectableValue)),
+    [optionSearcher, inputValue]
+  );
+  return /* @__PURE__ */ React.createElement(MultiSelect, {
+    "data-testid": `GroupBySelect-${key}`,
+    id: key,
+    placeholder: "Select value",
+    width: "auto",
+    allowCustomValue,
+    inputValue,
+    value: uncommittedValue,
+    noMultiValueWrap: true,
+    maxVisibleValues: maxVisibleValues != null ? maxVisibleValues : 5,
+    tabSelectsValue: false,
+    virtualized: true,
+    options: filteredOptions,
+    filterOption: filterNoOp,
+    closeMenuOnSelect: false,
+    isOpen: isOptionsOpen,
+    isClearable: true,
+    hideSelectedOptions: false,
+    isLoading: isFetchingOptions,
+    components: { Option: OptionWithCheckbox },
+    onInputChange,
+    onBlur: () => {
+      model.changeValueTo(
+        uncommittedValue.map((x) => x.value),
+        uncommittedValue.map((x) => x.label)
+      );
+    },
+    onChange: (newValue, action) => {
+      if (action.action === "clear" && noValueOnClear) {
+        model.changeValueTo([]);
+      }
+      setUncommittedValue(newValue);
+    },
+    onOpenMenu: async () => {
+      setIsFetchingOptions(true);
+      await lastValueFrom(model.validateAndUpdate());
+      setIsFetchingOptions(false);
+      setIsOptionsOpen(true);
+    },
+    onCloseMenu: () => {
+      setIsOptionsOpen(false);
+    }
+  });
+}
+const filterNoOp = () => true;
+function toSelectableValue(input) {
+  const { label, value, group } = input;
+  const result = {
+    label,
+    value
+  };
+  if (group) {
+    result.group = group;
+  }
+  return result;
+}
+
+export { GroupByVariable, GroupByVariableRenderer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"GroupByVariable.js","sources":["../../../../variables/groupby/GroupByVariable.js"],"sourcesContent":["import React, { useMemo, useState, useEffect } from 'react';\nimport { allActiveGroupByVariables } from './findActiveGroupByVariablesByUid.js';\nimport { sceneGraph } from '../../core/sceneGraph/index.js';\nimport { MultiValueVariable } from '../variants/MultiValueVariable.js';\nimport { map, of, from, mergeMap, tap, take, lastValueFrom } from 'rxjs';\nimport { getDataSource } from '../../utils/getDataSource.js';\nimport { MultiSelect } from '@grafana/ui';\nimport { isArray } from 'lodash';\nimport { dataFromResponse, getQueriesForVariables, responseHasError, handleOptionGroups } from '../utils.js';\nimport { OptionWithCheckbox } from '../components/VariableValueSelect.js';\nimport { GroupByVariableUrlSyncHandler } from './GroupByVariableUrlSyncHandler.js';\nimport { getOptionSearcher } from '../components/getOptionSearcher.js';\nimport { getEnrichedFiltersRequest } from '../getEnrichedFiltersRequest.js';\nimport { wrapInSafeSerializableSceneObject } from '../../utils/wrapInSafeSerializableSceneObject.js';\n\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nclass GroupByVariable extends MultiValueVariable {\n  constructor(initialState) {\n    super(__spreadProps(__spreadValues({\n      isMulti: true,\n      name: \"\",\n      value: [],\n      text: [],\n      options: [],\n      datasource: null,\n      baseFilters: [],\n      applyMode: \"auto\",\n      layout: \"horizontal\",\n      type: \"groupby\"\n    }, initialState), {\n      noValueOnClear: true\n    }));\n    this.isLazy = true;\n    this._urlSync = new GroupByVariableUrlSyncHandler(this);\n    this._getKeys = async (ds) => {\n      var _a, _b, _c;\n      const override = await ((_b = (_a = this.state).getTagKeysProvider) == null ? void 0 : _b.call(_a, this, null));\n      if (override && override.replace) {\n        return override.values;\n      }\n      if (this.state.defaultOptions) {\n        return this.state.defaultOptions.concat(dataFromResponse((_c = override == null ? void 0 : override.values) != null ? _c : []));\n      }\n      if (!ds.getTagKeys) {\n        return [];\n      }\n      const queries = getQueriesForVariables(this);\n      const otherFilters = this.state.baseFilters || [];\n      const timeRange = sceneGraph.getTimeRange(this).state.value;\n      const response = await ds.getTagKeys(__spreadValues({\n        filters: otherFilters,\n        queries,\n        timeRange\n      }, getEnrichedFiltersRequest(this)));\n      if (responseHasError(response)) {\n        this.setState({ error: response.error.message });\n      }\n      let keys = dataFromResponse(response);\n      if (override) {\n        keys = keys.concat(dataFromResponse(override.values));\n      }\n      const tagKeyRegexFilter = this.state.tagKeyRegexFilter;\n      if (tagKeyRegexFilter) {\n        keys = keys.filter((f) => f.text.match(tagKeyRegexFilter));\n      }\n      return keys;\n    };\n    this.addActivationHandler(() => {\n      allActiveGroupByVariables.add(this);\n      return () => allActiveGroupByVariables.delete(this);\n    });\n  }\n  validateAndUpdate() {\n    return this.getValueOptions({}).pipe(\n      map((options) => {\n        this._updateValueGivenNewOptions(options);\n        return {};\n      })\n    );\n  }\n  _updateValueGivenNewOptions(options) {\n    const { value: currentValue, text: currentText } = this.state;\n    const stateUpdate = {\n      options,\n      loading: false,\n      value: currentValue != null ? currentValue : [],\n      text: currentText != null ? currentText : []\n    };\n    this.setState(stateUpdate);\n  }\n  getValueOptions(args) {\n    if (this.state.defaultOptions) {\n      return of(\n        this.state.defaultOptions.map((o) => ({\n          label: o.text,\n          value: String(o.value),\n          group: o.group\n        }))\n      );\n    }\n    this.setState({ loading: true, error: null });\n    return from(\n      getDataSource(this.state.datasource, {\n        __sceneObject: wrapInSafeSerializableSceneObject(this)\n      })\n    ).pipe(\n      mergeMap((ds) => {\n        return from(this._getKeys(ds)).pipe(\n          tap((response) => {\n            if (responseHasError(response)) {\n              this.setState({ error: response.error.message });\n            }\n          }),\n          map((response) => dataFromResponse(response)),\n          take(1),\n          mergeMap((data) => {\n            const a = data.map((i) => {\n              return {\n                label: i.text,\n                value: i.value ? String(i.value) : i.text,\n                group: i.group\n              };\n            });\n            return of(a);\n          })\n        );\n      })\n    );\n  }\n  getDefaultMultiState(options) {\n    return { value: [], text: [] };\n  }\n}\nGroupByVariable.Component = GroupByVariableRenderer;\nfunction GroupByVariableRenderer({ model }) {\n  const {\n    value,\n    text,\n    key,\n    maxVisibleValues,\n    noValueOnClear,\n    options,\n    includeAll,\n    allowCustomValue = true\n  } = model.useState();\n  const values = useMemo(() => {\n    const arrayValue = isArray(value) ? value : [value];\n    const arrayText = isArray(text) ? text : [text];\n    return arrayValue.map((value2, idx) => {\n      var _a;\n      return {\n        value: value2,\n        label: String((_a = arrayText[idx]) != null ? _a : value2)\n      };\n    });\n  }, [value, text]);\n  const [isFetchingOptions, setIsFetchingOptions] = useState(false);\n  const [isOptionsOpen, setIsOptionsOpen] = useState(false);\n  const [inputValue, setInputValue] = useState(\"\");\n  const [uncommittedValue, setUncommittedValue] = useState(values);\n  const optionSearcher = useMemo(() => getOptionSearcher(options, includeAll), [options, includeAll]);\n  useEffect(() => {\n    setUncommittedValue(values);\n  }, [values]);\n  const onInputChange = (value2, { action }) => {\n    if (action === \"input-change\") {\n      setInputValue(value2);\n      if (model.onSearchChange) {\n        model.onSearchChange(value2);\n      }\n      return value2;\n    }\n    if (action === \"input-blur\") {\n      setInputValue(\"\");\n      return \"\";\n    }\n    return inputValue;\n  };\n  const filteredOptions = useMemo(\n    () => handleOptionGroups(optionSearcher(inputValue).map(toSelectableValue)),\n    [optionSearcher, inputValue]\n  );\n  return /* @__PURE__ */ React.createElement(MultiSelect, {\n    \"data-testid\": `GroupBySelect-${key}`,\n    id: key,\n    placeholder: \"Select value\",\n    width: \"auto\",\n    allowCustomValue,\n    inputValue,\n    value: uncommittedValue,\n    noMultiValueWrap: true,\n    maxVisibleValues: maxVisibleValues != null ? maxVisibleValues : 5,\n    tabSelectsValue: false,\n    virtualized: true,\n    options: filteredOptions,\n    filterOption: filterNoOp,\n    closeMenuOnSelect: false,\n    isOpen: isOptionsOpen,\n    isClearable: true,\n    hideSelectedOptions: false,\n    isLoading: isFetchingOptions,\n    components: { Option: OptionWithCheckbox },\n    onInputChange,\n    onBlur: () => {\n      model.changeValueTo(\n        uncommittedValue.map((x) => x.value),\n        uncommittedValue.map((x) => x.label)\n      );\n    },\n    onChange: (newValue, action) => {\n      if (action.action === \"clear\" && noValueOnClear) {\n        model.changeValueTo([]);\n      }\n      setUncommittedValue(newValue);\n    },\n    onOpenMenu: async () => {\n      setIsFetchingOptions(true);\n      await lastValueFrom(model.validateAndUpdate());\n      setIsFetchingOptions(false);\n      setIsOptionsOpen(true);\n    },\n    onCloseMenu: () => {\n      setIsOptionsOpen(false);\n    }\n  });\n}\nconst filterNoOp = () => true;\nfunction toSelectableValue(input) {\n  const { label, value, group } = input;\n  const result = {\n    label,\n    value\n  };\n  if (group) {\n    result.group = group;\n  }\n  return result;\n}\n\nexport { GroupByVariable, GroupByVariableRenderer };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"GroupByVariable.js","sources":["../../../../src/variables/groupby/GroupByVariable.tsx"],"sourcesContent":["import React, { useEffect, useMemo, useState } from 'react';\nimport { AdHocVariableFilter, DataSourceApi, GetTagResponse, MetricFindValue, SelectableValue } from '@grafana/data';\nimport { allActiveGroupByVariables } from './findActiveGroupByVariablesByUid';\nimport { DataSourceRef, VariableType } from '@grafana/schema';\nimport { SceneComponentProps, ControlsLayout, SceneObjectUrlSyncHandler } from '../../core/types';\nimport { sceneGraph } from '../../core/sceneGraph';\nimport { ValidateAndUpdateResult, VariableValueOption, VariableValueSingle } from '../types';\nimport { MultiValueVariable, MultiValueVariableState, VariableGetOptionsArgs } from '../variants/MultiValueVariable';\nimport { from, lastValueFrom, map, mergeMap, Observable, of, take, tap } from 'rxjs';\nimport { getDataSource } from '../../utils/getDataSource';\nimport { InputActionMeta, MultiSelect } from '@grafana/ui';\nimport { isArray } from 'lodash';\nimport { dataFromResponse, getQueriesForVariables, handleOptionGroups, responseHasError } from '../utils';\nimport { OptionWithCheckbox } from '../components/VariableValueSelect';\nimport { GroupByVariableUrlSyncHandler } from './GroupByVariableUrlSyncHandler';\nimport { getOptionSearcher } from '../components/getOptionSearcher';\nimport { getEnrichedFiltersRequest } from '../getEnrichedFiltersRequest';\nimport { wrapInSafeSerializableSceneObject } from '../../utils/wrapInSafeSerializableSceneObject';\n\nexport interface GroupByVariableState extends MultiValueVariableState {\n  /** Defaults to \"Group\" */\n  name: string;\n  /** The visible keys to group on */\n  // TODO review this type and name (naming is hard)\n  defaultOptions?: MetricFindValue[];\n  /** Base filters to always apply when looking up keys */\n  baseFilters?: AdHocVariableFilter[];\n  /** Datasource to use for getTagKeys and also controls which scene queries the group by should apply to */\n  datasource: DataSourceRef | null;\n  /** Controls if the group by can be changed */\n  readOnly?: boolean;\n  /**\n   * @experimental\n   * Controls the layout and design of the label.\n   * Vertical layout does not yet support operator selector.\n   */\n  layout?: ControlsLayout;\n  /**\n   * Defaults to same-datasource which means group by will automatically be applied to all queries with the same data source as this GroupBySet.\n   * In manual mode no queries are re-run on changes, and you have to manually apply the filter to whatever queries you want.\n   */\n  applyMode?: 'auto' | 'manual';\n  /**\n   * Filter out the keys that do not match the regex.\n   */\n  tagKeyRegexFilter?: RegExp;\n  /**\n   * Extension hook for customizing the key lookup.\n   * Return replace: true if you want to override the default lookup\n   * Return replace: false if you want to combine the results with the default lookup\n   */\n  getTagKeysProvider?: getTagKeysProvider;\n}\n\nexport type getTagKeysProvider = (\n  set: GroupByVariable,\n  currentKey: string | null\n) => Promise<{ replace?: boolean; values: MetricFindValue[] | GetTagResponse }>;\n\nexport class GroupByVariable extends MultiValueVariable<GroupByVariableState> {\n  static Component = GroupByVariableRenderer;\n  isLazy = true;\n\n  protected _urlSync: SceneObjectUrlSyncHandler = new GroupByVariableUrlSyncHandler(this);\n\n  public validateAndUpdate(): Observable<ValidateAndUpdateResult> {\n    return this.getValueOptions({}).pipe(\n      map((options) => {\n        this._updateValueGivenNewOptions(options);\n        return {};\n      })\n    );\n  }\n\n  private _updateValueGivenNewOptions(options: VariableValueOption[]) {\n    const { value: currentValue, text: currentText } = this.state;\n\n    const stateUpdate: Partial<MultiValueVariableState> = {\n      options,\n      loading: false,\n      value: currentValue ?? [],\n      text: currentText ?? [],\n    };\n\n    this.setState(stateUpdate);\n  }\n\n  public getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]> {\n    // When default dimensions are provided, return the static list\n    if (this.state.defaultOptions) {\n      return of(\n        this.state.defaultOptions.map((o) => ({\n          label: o.text,\n          value: String(o.value),\n          group: o.group,\n        }))\n      );\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        return from(this._getKeys(ds)).pipe(\n          tap((response) => {\n            if (responseHasError(response)) {\n              this.setState({ error: response.error.message });\n            }\n          }),\n          map((response) => dataFromResponse(response)),\n          take(1),\n          mergeMap((data) => {\n            const a: VariableValueOption[] = data.map((i) => {\n              return {\n                label: i.text,\n                value: i.value ? String(i.value) : i.text,\n                group: i.group,\n              };\n            });\n            return of(a);\n          })\n        );\n      })\n    );\n  }\n\n  public constructor(initialState: Partial<GroupByVariableState>) {\n    super({\n      isMulti: true,\n      name: '',\n      value: [],\n      text: [],\n      options: [],\n      datasource: null,\n      baseFilters: [],\n      applyMode: 'auto',\n      layout: 'horizontal',\n      type: 'groupby' as VariableType,\n      ...initialState,\n      noValueOnClear: true,\n    });\n\n    this.addActivationHandler(() => {\n      allActiveGroupByVariables.add(this);\n\n      return () => allActiveGroupByVariables.delete(this);\n    });\n  }\n\n  /**\n   * Get possible keys given current filters. Do not call from plugins directly\n   */\n  public _getKeys = async (ds: DataSourceApi) => {\n    // TODO:  provide current dimensions?\n    const override = await this.state.getTagKeysProvider?.(this, null);\n\n    if (override && override.replace) {\n      return override.values;\n    }\n\n    if (this.state.defaultOptions) {\n      return this.state.defaultOptions.concat(dataFromResponse(override?.values ?? []));\n    }\n\n    if (!ds.getTagKeys) {\n      return [];\n    }\n\n    const queries = getQueriesForVariables(this);\n\n    const otherFilters = this.state.baseFilters || [];\n    const timeRange = sceneGraph.getTimeRange(this).state.value;\n    const response = await ds.getTagKeys({\n      filters: otherFilters,\n      queries,\n      timeRange,\n      ...getEnrichedFiltersRequest(this),\n    });\n    if (responseHasError(response)) {\n      this.setState({ error: response.error.message });\n    }\n\n    let keys = dataFromResponse(response);\n    if (override) {\n      keys = keys.concat(dataFromResponse(override.values));\n    }\n\n    const tagKeyRegexFilter = this.state.tagKeyRegexFilter;\n    if (tagKeyRegexFilter) {\n      keys = keys.filter((f) => f.text.match(tagKeyRegexFilter));\n    }\n\n    return keys;\n  };\n\n  /**\n   * Allows clearing the value of the variable to an empty value. Overrides default behavior of a MultiValueVariable\n   */\n  public getDefaultMultiState(options: VariableValueOption[]): { value: VariableValueSingle[]; text: string[] } {\n    return { value: [], text: [] };\n  }\n}\nexport function GroupByVariableRenderer({ model }: SceneComponentProps<MultiValueVariable>) {\n  const {\n    value,\n    text,\n    key,\n    maxVisibleValues,\n    noValueOnClear,\n    options,\n    includeAll,\n    allowCustomValue = true,\n  } = model.useState();\n\n  const values = useMemo<Array<SelectableValue<VariableValueSingle>>>(() => {\n    const arrayValue = isArray(value) ? value : [value];\n    const arrayText = isArray(text) ? text : [text];\n\n    return arrayValue.map((value, idx) => ({\n      value,\n      label: String(arrayText[idx] ?? value),\n    }));\n  }, [value, text]);\n\n  const [isFetchingOptions, setIsFetchingOptions] = useState(false);\n  const [isOptionsOpen, setIsOptionsOpen] = useState(false);\n  const [inputValue, setInputValue] = useState('');\n\n  // To not trigger queries on every selection we store this state locally here and only update the variable onBlur\n  const [uncommittedValue, setUncommittedValue] = useState(values);\n\n  const optionSearcher = useMemo(() => getOptionSearcher(options, includeAll), [options, includeAll]);\n\n  // Detect value changes outside\n  useEffect(() => {\n    setUncommittedValue(values);\n  }, [values]);\n\n  const onInputChange = (value: string, { action }: InputActionMeta) => {\n    if (action === 'input-change') {\n      setInputValue(value);\n      if (model.onSearchChange) {\n        model.onSearchChange!(value);\n      }\n      return value;\n    }\n\n    if (action === 'input-blur') {\n      setInputValue('');\n      return '';\n    }\n\n    return inputValue;\n  };\n\n  const filteredOptions = useMemo(\n    () => handleOptionGroups(optionSearcher(inputValue).map(toSelectableValue)),\n    [optionSearcher, inputValue]\n  );\n\n  return (\n    <MultiSelect<VariableValueSingle>\n      data-testid={`GroupBySelect-${key}`}\n      id={key}\n      placeholder={'Select value'}\n      width=\"auto\"\n      allowCustomValue={allowCustomValue}\n      inputValue={inputValue}\n      value={uncommittedValue}\n      noMultiValueWrap={true}\n      maxVisibleValues={maxVisibleValues ?? 5}\n      tabSelectsValue={false}\n      virtualized\n      options={filteredOptions}\n      filterOption={filterNoOp}\n      closeMenuOnSelect={false}\n      isOpen={isOptionsOpen}\n      isClearable={true}\n      hideSelectedOptions={false}\n      isLoading={isFetchingOptions}\n      components={{ Option: OptionWithCheckbox }}\n      onInputChange={onInputChange}\n      onBlur={() => {\n        model.changeValueTo(\n          uncommittedValue.map((x) => x.value!),\n          uncommittedValue.map((x) => x.label!)\n        );\n      }}\n      onChange={(newValue, action) => {\n        if (action.action === 'clear' && noValueOnClear) {\n          model.changeValueTo([]);\n        }\n        setUncommittedValue(newValue);\n      }}\n      onOpenMenu={async () => {\n        setIsFetchingOptions(true);\n        await lastValueFrom(model.validateAndUpdate());\n        setIsFetchingOptions(false);\n        setIsOptionsOpen(true);\n      }}\n      onCloseMenu={() => {\n        setIsOptionsOpen(false);\n      }}\n    />\n  );\n}\n\nconst filterNoOp = () => true;\n\nfunction toSelectableValue(input: VariableValueOption): SelectableValue<VariableValueSingle> {\n  const { label, value, group } = input;\n  const result: SelectableValue<VariableValueSingle> = {\n    label,\n    value,\n  };\n\n  if (group) {\n    result.group = group;\n  }\n\n  return result;\n}\n"],"names":["value"],"mappings":"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"}\n"],"names":["value"],"mappings":"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"}

package/dist/esm/dist/esm/variables/groupby/GroupByVariableUrlSyncHandler.js

@@ -0,0 +1,63 @@
+import { toUrlCommaDelimitedString, unescapeUrlDelimiters } from '../utils.js';
+
+class GroupByVariableUrlSyncHandler {
+  constructor(_sceneObject) {
+    this._sceneObject = _sceneObject;
+  }
+  getKey() {
+    return `var-${this._sceneObject.state.name}`;
+  }
+  getKeys() {
+    if (this._sceneObject.state.skipUrlSync) {
+      return [];
+    }
+    return [this.getKey()];
+  }
+  getUrlState() {
+    if (this._sceneObject.state.skipUrlSync) {
+      return {};
+    }
+    return { [this.getKey()]: toUrlValues(this._sceneObject.state.value, this._sceneObject.state.text) };
+  }
+  updateFromUrl(values) {
+    let urlValue = values[this.getKey()];
+    if (urlValue != null) {
+      if (!this._sceneObject.isActive) {
+        this._sceneObject.skipNextValidation = true;
+      }
+      const { values: values2, texts } = fromUrlValues(urlValue);
+      this._sceneObject.changeValueTo(values2, texts);
+    }
+  }
+}
+function toUrlValues(values, texts) {
+  values = Array.isArray(values) ? values : [values];
+  texts = Array.isArray(texts) ? texts : [texts];
+  return values.map((value, idx) => {
+    if (value === void 0 || value === null) {
+      return "";
+    }
+    value = String(value);
+    let text = texts[idx];
+    text = text === void 0 || text === null ? value : String(text);
+    return toUrlCommaDelimitedString(value, text);
+  });
+}
+function fromUrlValues(urlValues) {
+  urlValues = Array.isArray(urlValues) ? urlValues : [urlValues];
+  return urlValues.reduce(
+    (acc, urlValue) => {
+      const [value, label] = (urlValue != null ? urlValue : "").split(",");
+      acc.values.push(unescapeUrlDelimiters(value));
+      acc.texts.push(unescapeUrlDelimiters(label != null ? label : value));
+      return acc;
+    },
+    {
+      values: [],
+      texts: []
+    }
+  );
+}
+
+export { GroupByVariableUrlSyncHandler };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"GroupByVariableUrlSyncHandler.js","sources":["../../../../variables/groupby/GroupByVariableUrlSyncHandler.js"],"sourcesContent":["import { toUrlCommaDelimitedString, unescapeUrlDelimiters } from '../utils.js';\n\nclass GroupByVariableUrlSyncHandler {\n  constructor(_sceneObject) {\n    this._sceneObject = _sceneObject;\n  }\n  getKey() {\n    return `var-${this._sceneObject.state.name}`;\n  }\n  getKeys() {\n    if (this._sceneObject.state.skipUrlSync) {\n      return [];\n    }\n    return [this.getKey()];\n  }\n  getUrlState() {\n    if (this._sceneObject.state.skipUrlSync) {\n      return {};\n    }\n    return { [this.getKey()]: toUrlValues(this._sceneObject.state.value, this._sceneObject.state.text) };\n  }\n  updateFromUrl(values) {\n    let urlValue = values[this.getKey()];\n    if (urlValue != null) {\n      if (!this._sceneObject.isActive) {\n        this._sceneObject.skipNextValidation = true;\n      }\n      const { values: values2, texts } = fromUrlValues(urlValue);\n      this._sceneObject.changeValueTo(values2, texts);\n    }\n  }\n}\nfunction toUrlValues(values, texts) {\n  values = Array.isArray(values) ? values : [values];\n  texts = Array.isArray(texts) ? texts : [texts];\n  return values.map((value, idx) => {\n    if (value === void 0 || value === null) {\n      return \"\";\n    }\n    value = String(value);\n    let text = texts[idx];\n    text = text === void 0 || text === null ? value : String(text);\n    return toUrlCommaDelimitedString(value, text);\n  });\n}\nfunction fromUrlValues(urlValues) {\n  urlValues = Array.isArray(urlValues) ? urlValues : [urlValues];\n  return urlValues.reduce(\n    (acc, urlValue) => {\n      const [value, label] = (urlValue != null ? urlValue : \"\").split(\",\");\n      acc.values.push(unescapeUrlDelimiters(value));\n      acc.texts.push(unescapeUrlDelimiters(label != null ? label : value));\n      return acc;\n    },\n    {\n      values: [],\n      texts: []\n    }\n  );\n}\n\nexport { GroupByVariableUrlSyncHandler };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n"],"names":["values"],"mappings":"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"}

package/dist/esm/dist/esm/variables/groupby/findActiveGroupByVariablesByUid.js

@@ -0,0 +1,13 @@
+const allActiveGroupByVariables = /* @__PURE__ */ new Set();
+function findActiveGroupByVariablesByUid(dsUid) {
+  var _a;
+  for (const groupByVariable of allActiveGroupByVariables.values()) {
+    if (((_a = groupByVariable.state.datasource) == null ? void 0 : _a.uid) === dsUid) {
+      return groupByVariable;
+    }
+  }
+  return void 0;
+}
+
+export { allActiveGroupByVariables, findActiveGroupByVariablesByUid };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/dist/esm/variables/interpolation/ScopedVarsVariable.js

@@ -0,0 +1,40 @@
+import { getFieldAccessor } from './fieldAccessorCache.js';
+
+class ScopedVarsVariable {
+  constructor(name, value) {
+    this.state = { name, value, type: "scopedvar" };
+  }
+  getValue(fieldPath) {
+    let { value } = this.state;
+    let realValue = value.value;
+    if (fieldPath) {
+      realValue = getFieldAccessor(fieldPath)(value.value);
+    } else {
+      realValue = value.value;
+    }
+    if (realValue === "string" || realValue === "number" || realValue === "boolean") {
+      return realValue;
+    }
+    return String(realValue);
+  }
+  getValueText() {
+    const { value } = this.state;
+    if (value.text != null) {
+      return String(value.text);
+    }
+    return String(value);
+  }
+}
+let scopedVarsVariable;
+function getSceneVariableForScopedVar(name, value) {
+  if (!scopedVarsVariable) {
+    scopedVarsVariable = new ScopedVarsVariable(name, value);
+  } else {
+    scopedVarsVariable.state.name = name;
+    scopedVarsVariable.state.value = value;
+  }
+  return scopedVarsVariable;
+}
+
+export { ScopedVarsVariable, getSceneVariableForScopedVar };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ScopedVarsVariable.js","sources":["../../../../variables/interpolation/ScopedVarsVariable.js"],"sourcesContent":["import { getFieldAccessor } from './fieldAccessorCache.js';\n\nclass ScopedVarsVariable {\n  constructor(name, value) {\n    this.state = { name, value, type: \"scopedvar\" };\n  }\n  getValue(fieldPath) {\n    let { value } = this.state;\n    let realValue = value.value;\n    if (fieldPath) {\n      realValue = getFieldAccessor(fieldPath)(value.value);\n    } else {\n      realValue = value.value;\n    }\n    if (realValue === \"string\" || realValue === \"number\" || realValue === \"boolean\") {\n      return realValue;\n    }\n    return String(realValue);\n  }\n  getValueText() {\n    const { value } = this.state;\n    if (value.text != null) {\n      return String(value.text);\n    }\n    return String(value);\n  }\n}\nlet scopedVarsVariable;\nfunction getSceneVariableForScopedVar(name, value) {\n  if (!scopedVarsVariable) {\n    scopedVarsVariable = new ScopedVarsVariable(name, value);\n  } else {\n    scopedVarsVariable.state.name = name;\n    scopedVarsVariable.state.value = value;\n  }\n  return scopedVarsVariable;\n}\n\nexport { ScopedVarsVariable, getSceneVariableForScopedVar };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n"],"names":[],"mappings":";;AAOO,MAAM,kBAA6C,CAAA;AAGjD,EAAA,WAAA,CAAY,MAAc,KAAkB,EAAA;AACjD,IAAA,IAAA,CAAK,KAAQ,GAAA,EAAE,IAAM,EAAA,KAAA,EAAO,MAAM,WAAY,EAAA,CAAA;AAAA,GAAA;AAGzC,EAAA,QAAA,CAAS,SAAkC,EAAA;AAC5C,IAAA,IAAA,EAAE,KAAM,EAAA,GAAI,IAAK,CAAA,KAAA,CAAA;AACrB,IAAA,IAAI,YAAY,KAAM,CAAA,KAAA,CAAA;AAEtB,IAAA,IAAI,SAAW,EAAA;AACb,MAAA,SAAA,GAAY,gBAAiB,CAAA,SAAS,CAAE,CAAA,KAAA,CAAM,KAAK,CAAA,CAAA;KAC9C,MAAA;AACL,MAAA,SAAA,GAAY,KAAM,CAAA,KAAA,CAAA;AAAA,KAAA;AAGpB,IAAA,IAAI,SAAc,KAAA,QAAA,IAAY,SAAc,KAAA,QAAA,IAAY,cAAc,SAAW,EAAA;AACxE,MAAA,OAAA,SAAA,CAAA;AAAA,KAAA;AAGT,IAAA,OAAO,OAAO,SAAS,CAAA,CAAA;AAAA,GAAA;EAGlB,YAAuB,GAAA;AACtB,IAAA,MAAA,EAAE,KAAM,EAAA,GAAI,IAAK,CAAA,KAAA,CAAA;AAEnB,IAAA,IAAA,KAAA,CAAM,QAAQ,IAAM,EAAA;AACf,MAAA,OAAA,MAAA,CAAO,MAAM,IAAI,CAAA,CAAA;AAAA,KAAA;AAG1B,IAAA,OAAO,OAAO,KAAK,CAAA,CAAA;AAAA,GAAA;AAEvB,CAAA;AAEA,IAAI,kBAAA,CAAA;AAKY,SAAA,4BAAA,CAA6B,MAAc,KAAkC,EAAA;AAC3F,EAAA,IAAI,CAAC,kBAAoB,EAAA;AACF,IAAA,kBAAA,GAAA,IAAI,kBAAmB,CAAA,IAAA,EAAM,KAAK,CAAA,CAAA;GAClD,MAAA;AACL,IAAA,kBAAA,CAAmB,MAAM,IAAO,GAAA,IAAA,CAAA;AAChC,IAAA,kBAAA,CAAmB,MAAM,KAAQ,GAAA,KAAA,CAAA;AAAA,GAAA;AAG5B,EAAA,OAAA,kBAAA,CAAA;AACT;;;;"}

package/dist/esm/dist/esm/variables/interpolation/defaults.js

@@ -0,0 +1,21 @@
+import { SceneDataNode } from '../../core/SceneDataNode.js';
+import { SceneObjectBase } from '../../core/SceneObjectBase.js';
+import { SceneTimeRange } from '../../core/SceneTimeRange.js';
+
+const EmptyDataNode = new SceneDataNode();
+const DefaultTimeRange = new SceneTimeRange();
+class EmptyVariableSetImpl extends SceneObjectBase {
+  constructor() {
+    super({ variables: [] });
+  }
+  getByName(name) {
+    return void 0;
+  }
+  isVariableLoadingOrWaitingToUpdate(variable) {
+    return false;
+  }
+}
+const EmptyVariableSet = new EmptyVariableSetImpl();
+
+export { DefaultTimeRange, EmptyDataNode, EmptyVariableSet, EmptyVariableSetImpl };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/dist/esm/variables/interpolation/fieldAccessorCache.js

@@ -0,0 +1,13 @@
+import { property } from 'lodash';
+
+let fieldAccessorCache = {};
+function getFieldAccessor(fieldPath) {
+  const accessor = fieldAccessorCache[fieldPath];
+  if (accessor) {
+    return accessor;
+  }
+  return fieldAccessorCache[fieldPath] = property(fieldPath);
+}
+
+export { getFieldAccessor };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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