@grafana/scenes 6.7.0 → 6.8.0

package/dist/esm/src/variables/variants/CustomVariable.js

@@ -0,0 +1,60 @@
+import { of } from 'rxjs';
+import { VariableDependencyConfig } from '../VariableDependencyConfig.js';
+import { renderSelectForVariable } from '../components/VariableValueSelect.js';
+import { MultiValueVariable } from './MultiValueVariable.js';
+import { sceneGraph } from '../../core/sceneGraph/index.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 CustomVariable extends MultiValueVariable {
+  constructor(initialState) {
+    super(__spreadValues({
+      type: "custom",
+      query: "",
+      value: "",
+      text: "",
+      options: [],
+      name: ""
+    }, initialState));
+    this._variableDependency = new VariableDependencyConfig(this, {
+      statePaths: ["query"]
+    });
+  }
+  getValueOptions(args) {
+    var _a;
+    const interpolated = sceneGraph.interpolate(this, this.state.query);
+    const match = (_a = interpolated.match(/(?:\\,|[^,])+/g)) != null ? _a : [];
+    const options = match.map((text) => {
+      var _a2;
+      text = text.replace(/\\,/g, ",");
+      const textMatch = (_a2 = /^(.+)\s:\s(.+)$/g.exec(text)) != null ? _a2 : [];
+      if (textMatch.length === 3) {
+        const [, key, value] = textMatch;
+        return { label: key.trim(), value: value.trim() };
+      } else {
+        return { label: text.trim(), value: text.trim() };
+      }
+    });
+    return of(options);
+  }
+}
+CustomVariable.Component = ({ model }) => {
+  return renderSelectForVariable(model);
+};
+
+export { CustomVariable };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/variables/variants/DataSourceVariable.js

@@ -0,0 +1,88 @@
+import { of } from 'rxjs';
+import { stringToJsRegex } from '@grafana/data';
+import { getDataSourceSrv } from '@grafana/runtime';
+import { sceneGraph } from '../../core/sceneGraph/index.js';
+import { VariableDependencyConfig } from '../VariableDependencyConfig.js';
+import { renderSelectForVariable } from '../components/VariableValueSelect.js';
+import { MultiValueVariable } from './MultiValueVariable.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 DataSourceVariable extends MultiValueVariable {
+  constructor(initialState) {
+    super(__spreadValues({
+      type: "datasource",
+      value: "",
+      text: "",
+      options: [],
+      name: "",
+      regex: "",
+      pluginId: ""
+    }, initialState));
+    this._variableDependency = new VariableDependencyConfig(this, {
+      statePaths: ["regex"]
+    });
+  }
+  getValueOptions(args) {
+    if (!this.state.pluginId) {
+      return of([]);
+    }
+    const dataSources = getDataSourceSrv().getList({ metrics: true, variables: false, pluginId: this.state.pluginId });
+    let regex;
+    if (this.state.regex) {
+      const interpolated = sceneGraph.interpolate(this, this.state.regex, void 0, "regex");
+      regex = stringToJsRegex(interpolated);
+    }
+    const options = [];
+    for (let i = 0; i < dataSources.length; i++) {
+      const source = dataSources[i];
+      if (isValid(source, regex)) {
+        options.push({ label: source.name, value: source.uid });
+      }
+      if (this.state.defaultOptionEnabled && isDefault(source, regex)) {
+        options.push({ label: "default", value: "default" });
+      }
+    }
+    if (options.length === 0) {
+      this.setState({ error: "No data sources found" });
+    } else if (this.state.error) {
+      this.setState({ error: null });
+    }
+    return of(options);
+  }
+}
+DataSourceVariable.Component = ({ model }) => {
+  return renderSelectForVariable(model);
+};
+function isValid(source, regex) {
+  if (!regex) {
+    return true;
+  }
+  return regex.exec(source.name);
+}
+function isDefault(source, regex) {
+  if (!source.isDefault) {
+    return false;
+  }
+  if (!regex) {
+    return true;
+  }
+  return regex.exec("default");
+}
+
+export { DataSourceVariable };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/variables/variants/IntervalVariable.js

@@ -0,0 +1,117 @@
+import { rangeUtil } from '@grafana/data';
+import { VariableRefresh } from '@grafana/schema';
+import { Select } from '@grafana/ui';
+import React from 'react';
+import { of } from 'rxjs';
+import { sceneGraph } from '../../core/sceneGraph/index.js';
+import { SceneObjectBase } from '../../core/SceneObjectBase.js';
+import { SceneObjectUrlSyncConfig } from '../../services/SceneObjectUrlSyncConfig.js';
+import { AUTO_VARIABLE_VALUE, AUTO_VARIABLE_TEXT } from '../constants.js';
+import { SceneVariableValueChangedEvent } from '../types.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 IntervalVariable extends SceneObjectBase {
+  constructor(initialState) {
+    super(__spreadValues({
+      type: "interval",
+      value: "",
+      intervals: ["1m", "10m", "30m", "1h", "6h", "12h", "1d", "7d", "14d", "30d"],
+      name: "",
+      autoStepCount: 30,
+      autoMinInterval: "10s",
+      autoEnabled: false,
+      refresh: VariableRefresh.onTimeRangeChanged
+    }, initialState));
+    this._onChange = (value) => {
+      this.setState({ value: value.value });
+      this.publishEvent(new SceneVariableValueChangedEvent(this), true);
+    };
+    this._urlSync = new SceneObjectUrlSyncConfig(this, { keys: () => [this.getKey()] });
+  }
+  getKey() {
+    return `var-${this.state.name}`;
+  }
+  getUrlState() {
+    return { [this.getKey()]: this.state.value };
+  }
+  updateFromUrl(values) {
+    const update = {};
+    const val = values[this.getKey()];
+    if (typeof val === "string") {
+      if (val.startsWith("$__auto_interval_")) {
+        update.value = AUTO_VARIABLE_VALUE;
+      } else {
+        update.value = val;
+      }
+    }
+    this.setState(update);
+  }
+  getOptionsForSelect() {
+    const { value: currentValue, intervals, autoEnabled } = this.state;
+    let options = intervals.map((interval) => ({ value: interval, label: interval }));
+    if (autoEnabled) {
+      options = [{ value: AUTO_VARIABLE_VALUE, label: AUTO_VARIABLE_TEXT }, ...options];
+    }
+    if (currentValue && !options.some((option) => option.value === currentValue)) {
+      options.push({ value: currentValue, label: currentValue });
+    }
+    return options;
+  }
+  getValue() {
+    const { value, autoStepCount, autoMinInterval } = this.state;
+    if (value === AUTO_VARIABLE_VALUE) {
+      return this.getAutoRefreshInteval(autoStepCount, autoMinInterval);
+    }
+    return value;
+  }
+  getAutoRefreshInteval(autoStepCount, minRefreshInterval) {
+    const timeRange = sceneGraph.getTimeRange(this).state.value;
+    const intervalObject = rangeUtil.calculateInterval(timeRange, autoStepCount, minRefreshInterval);
+    return intervalObject.interval;
+  }
+  validateAndUpdate() {
+    const { value, intervals } = this.state;
+    let shouldPublish = false;
+    if (value === AUTO_VARIABLE_VALUE) {
+      shouldPublish = true;
+    } else if (!value && intervals.length > 0) {
+      const firstOption = intervals[0];
+      this.setState({ value: firstOption });
+      shouldPublish = true;
+    }
+    if (shouldPublish) {
+      this.publishEvent(new SceneVariableValueChangedEvent(this), true);
+    }
+    return of({});
+  }
+}
+IntervalVariable.Component = ({ model }) => {
+  const { key, value } = model.useState();
+  return /* @__PURE__ */ React.createElement(Select, {
+    id: key,
+    placeholder: "Select value",
+    width: "auto",
+    value,
+    tabSelectsValue: false,
+    options: model.getOptionsForSelect(),
+    onChange: model._onChange
+  });
+};
+
+export { IntervalVariable };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"IntervalVariable.js","sources":["../../../../../src/variables/variants/IntervalVariable.tsx"],"sourcesContent":["import { rangeUtil, SelectableValue } from '@grafana/data';\nimport { VariableRefresh } from '@grafana/schema';\nimport { Select } from '@grafana/ui';\nimport React from 'react';\nimport { Observable, of } from 'rxjs';\nimport { sceneGraph } from '../../core/sceneGraph';\nimport { SceneObjectBase } from '../../core/SceneObjectBase';\nimport { SceneComponentProps, SceneObjectUrlValues } from '../../core/types';\nimport { SceneObjectUrlSyncConfig } from '../../services/SceneObjectUrlSyncConfig';\nimport { AUTO_VARIABLE_TEXT, AUTO_VARIABLE_VALUE } from '../constants';\nimport {\n  SceneVariable,\n  SceneVariableState,\n  SceneVariableValueChangedEvent,\n  ValidateAndUpdateResult,\n  VariableValue,\n} from '../types';\n\nexport interface IntervalVariableState extends SceneVariableState {\n  intervals: string[];\n  value: string;\n  autoEnabled: boolean;\n  autoMinInterval: string;\n  autoStepCount: number;\n  refresh: VariableRefresh;\n}\n\nexport class IntervalVariable\n  extends SceneObjectBase<IntervalVariableState>\n  implements SceneVariable<IntervalVariableState>\n{\n  public constructor(initialState: Partial<IntervalVariableState>) {\n    super({\n      type: 'interval',\n      value: '',\n      intervals: ['1m', '10m', '30m', '1h', '6h', '12h', '1d', '7d', '14d', '30d'],\n      name: '',\n      autoStepCount: 30,\n      autoMinInterval: '10s',\n      autoEnabled: false,\n      refresh: VariableRefresh.onTimeRangeChanged,\n      ...initialState,\n    });\n\n    this._urlSync = new SceneObjectUrlSyncConfig(this, { keys: () => [this.getKey()] });\n  }\n\n  private getKey(): string {\n    return `var-${this.state.name}`;\n  }\n\n  public getUrlState() {\n    return { [this.getKey()]: this.state.value };\n  }\n\n  public updateFromUrl(values: SceneObjectUrlValues) {\n    const update: Partial<IntervalVariableState> = {};\n    const val = values[this.getKey()];\n    if (typeof val === 'string') {\n      // support old auto interval url value\n      if (val.startsWith('$__auto_interval_')) {\n        update.value = AUTO_VARIABLE_VALUE;\n      } else {\n        update.value = val;\n      }\n    }\n    this.setState(update);\n  }\n\n  public getOptionsForSelect(): Array<SelectableValue<string>> {\n    const { value: currentValue, intervals, autoEnabled } = this.state;\n\n    let options = intervals.map((interval) => ({ value: interval, label: interval }));\n\n    if (autoEnabled) {\n      options = [{ value: AUTO_VARIABLE_VALUE, label: AUTO_VARIABLE_TEXT }, ...options];\n    }\n\n    // If the current value is not in the list of intervals, add it to the list\n    if (currentValue && !options.some((option) => option.value === currentValue)) {\n      options.push({ value: currentValue, label: currentValue });\n    }\n\n    return options;\n  }\n\n  public getValue(): VariableValue {\n    const { value, autoStepCount, autoMinInterval } = this.state;\n    if (value === AUTO_VARIABLE_VALUE) {\n      return this.getAutoRefreshInteval(autoStepCount, autoMinInterval);\n    }\n\n    return value;\n  }\n\n  private getAutoRefreshInteval(autoStepCount: number, minRefreshInterval: string) {\n    const timeRange = sceneGraph.getTimeRange(this).state.value;\n    const intervalObject = rangeUtil.calculateInterval(timeRange, autoStepCount, minRefreshInterval);\n    return intervalObject.interval;\n  }\n\n  public _onChange = (value: SelectableValue<string>) => {\n    this.setState({ value: value.value! });\n    this.publishEvent(new SceneVariableValueChangedEvent(this), true);\n  };\n\n  public validateAndUpdate(): Observable<ValidateAndUpdateResult> {\n    const { value, intervals } = this.state;\n    let shouldPublish = false;\n\n    if (value === AUTO_VARIABLE_VALUE) {\n      shouldPublish = true;\n    } else if (!value && intervals.length > 0) {\n      const firstOption = intervals[0];\n      this.setState({ value: firstOption });\n      shouldPublish = true;\n    }\n\n    if (shouldPublish) {\n      this.publishEvent(new SceneVariableValueChangedEvent(this), true);\n    }\n\n    return of({});\n  }\n\n  public static Component = ({ model }: SceneComponentProps<IntervalVariable>) => {\n    const { key, value } = model.useState();\n    return (\n      <Select\n        id={key}\n        placeholder=\"Select value\"\n        width=\"auto\"\n        value={value}\n        tabSelectsValue={false}\n        options={model.getOptionsForSelect()}\n        onChange={model._onChange}\n      />\n    );\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/src/variables/variants/JsonVariable.js

@@ -0,0 +1,193 @@
+import React from 'react';
+import { property } from 'lodash';
+import { Observable, of, map } from 'rxjs';
+import 'react-router-dom';
+import '@grafana/data';
+import '@grafana/runtime';
+import { SceneObjectBase } from '../../../dist/esm/core/SceneObjectBase.js';
+import '../../../dist/esm/core/SceneObjectRef.js';
+import '../../../dist/esm/variables/interpolation/defaults.js';
+import '@grafana/schema';
+import { SceneVariableValueChangedEvent } from '../../../dist/esm/variables/types.js';
+import '../../../dist/esm/variables/interpolation/formatRegistry.js';
+import '../../../dist/esm/variables/macros/index.js';
+import '../../../dist/esm/variables/variants/query/QueryVariable.js';
+import '../../../dist/esm/core/SceneDataNode.js';
+import '../../../dist/esm/variables/groupby/GroupByVariable.js';
+import '../../../dist/esm/variables/adhoc/AdHocFiltersVariable.js';
+import '../../../dist/esm/utils/SafeSerializableSceneObject.js';
+import '@leeoniya/ufuzzy';
+import '../../../dist/esm/core/events.js';
+import '../../../dist/esm/behaviors/LiveNowTimer.js';
+import '../../../dist/esm/querying/layers/annotations/AnnotationsDataLayer.js';
+import '../../../dist/esm/querying/SceneDataLayerSet.js';
+import '../../../dist/esm/querying/layers/SceneDataLayerControls.js';
+import '../../../dist/esm/variables/components/VariableValueSelectors.js';
+import '../../../dist/esm/variables/components/VariableValueControl.js';
+import '../../../dist/esm/variables/variants/CustomVariable.js';
+import '../../../dist/esm/variables/variants/DataSourceVariable.js';
+import '../../../dist/esm/variables/variants/TestVariable.js';
+import '../../../dist/esm/variables/variants/TextBoxVariable.js';
+import '../../../dist/esm/variables/variants/IntervalVariable.js';
+import '../../../dist/esm/services/UrlSyncManager.js';
+import '../../../dist/esm/components/EmbeddedScene.js';
+import '../../../dist/esm/components/VizPanel/VizPanel.js';
+import '../../../dist/esm/components/VizPanel/VizPanelMenu.js';
+import '../../../dist/esm/components/VizPanel/VizPanelExploreButton.js';
+import '../../../dist/esm/components/NestedScene.js';
+import '../../../dist/esm/components/SceneCanvasText.js';
+import '../../../dist/esm/components/SceneToolbarButton.js';
+import '../../../dist/esm/components/SceneTimePicker.js';
+import '../../../dist/esm/components/SceneRefreshPicker.js';
+import '../../../dist/esm/components/SceneTimeRangeCompare.js';
+import '../../../dist/esm/components/SceneByFrameRepeater.js';
+import '../../../dist/esm/components/SceneByVariableRepeater.js';
+import '../../../dist/esm/components/SceneControlsSpacer.js';
+import '../../../dist/esm/components/layout/SceneFlexLayout.js';
+import '../../../dist/esm/components/layout/CSSGrid/SceneCSSGridLayout.js';
+import '../../../dist/esm/components/layout/grid/SceneGridLayout.js';
+import '../../../dist/esm/components/layout/grid/SceneGridItem.js';
+import '../../../dist/esm/components/layout/grid/SceneGridRow.js';
+import '../../../dist/esm/components/layout/split/SplitLayout.js';
+import '../../../dist/esm/components/SceneApp/SceneApp.js';
+import '../../../dist/esm/components/SceneApp/SceneAppPage.js';
+import '../../../dist/esm/components/SceneReactObject.js';
+import '@grafana/schema/dist/esm/raw/composable/barchart/panelcfg/x/BarChartPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/bargauge/panelcfg/x/BarGaugePanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/datagrid/panelcfg/x/DatagridPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/gauge/panelcfg/x/GaugePanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/geomap/panelcfg/x/GeomapPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/heatmap/panelcfg/x/HeatmapPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/histogram/panelcfg/x/HistogramPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/news/panelcfg/x/NewsPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/piechart/panelcfg/x/PieChartPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/stat/panelcfg/x/StatPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/statetimeline/panelcfg/x/StateTimelinePanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/statushistory/panelcfg/x/StatusHistoryPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/table/panelcfg/x/TablePanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/text/panelcfg/x/TextPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/xychart/panelcfg/x/XYChartPanelCfg_types.gen';
+import '@emotion/css';
+import { Select } from '@grafana/ui';
+import '@grafana/e2e-selectors';
+import '../../../dist/esm/variables/components/VariableValueSelect.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;
+};
+const _JsonVariable = class extends SceneObjectBase {
+  constructor(state) {
+    super(__spreadValues({
+      type: "json"
+    }, state));
+    this._onChange = (selected) => {
+      this.setState({ value: selected.value });
+      this.publishEvent(new SceneVariableValueChangedEvent(this), true);
+    };
+  }
+  validateAndUpdate() {
+    if (!this.state.provider) {
+      return of({});
+    }
+    return this.state.provider.getOptions().pipe(
+      map((options) => {
+        console.log("options", options);
+        this.updateValueGivenNewOptions(options);
+        return {};
+      })
+    );
+  }
+  updateValueGivenNewOptions(options) {
+    if (!this.state.value) {
+      return;
+    }
+    const stateUpdate = { options };
+    const found = options.find((option) => option.value === this.state.value);
+    if (!found) {
+      if (options.length > 0) {
+        stateUpdate.value = options[0].value;
+      } else {
+        stateUpdate.value = void 0;
+      }
+    }
+    this.setState(stateUpdate);
+  }
+  getValueText(fieldPath) {
+    const current = this.state.options.find((option) => option.value === this.state.value);
+    return current ? current.label : "";
+  }
+  getValue(fieldPath) {
+    const current = this.state.options.find((option) => option.value === this.state.value);
+    return current ? this.getFieldAccessor(fieldPath)(current.obj) : "";
+  }
+  getFieldAccessor(fieldPath) {
+    const accessor = _JsonVariable.fieldAccessorCache[fieldPath];
+    if (accessor) {
+      return accessor;
+    }
+    return _JsonVariable.fieldAccessorCache[fieldPath] = property(fieldPath);
+  }
+};
+let JsonVariable = _JsonVariable;
+JsonVariable.fieldAccessorCache = {};
+JsonVariable.Component = ({ model }) => {
+  var _a;
+  const { key, value, options } = model.useState();
+  const current = (_a = options.find((option) => option.value === value)) == null ? void 0 : _a.value;
+  return /* @__PURE__ */ React.createElement(Select, {
+    id: key,
+    placeholder: "Select value",
+    width: "auto",
+    value: current,
+    tabSelectsValue: false,
+    options,
+    onChange: model._onChange
+  });
+};
+class JsonStringOptionPrivider {
+  constructor(options) {
+    this.options = options;
+  }
+  getOptions() {
+    return new Observable((subscriber) => {
+      try {
+        const { json, valueProp = "name" } = this.options;
+        const jsonValue = JSON.parse(json);
+        if (!Array.isArray(jsonValue)) {
+          throw new Error("JSON must be an array");
+        }
+        const resultOptions = [];
+        jsonValue.forEach((option) => {
+          if (option[valueProp] == null) {
+            return;
+          }
+          resultOptions.push({
+            value: option[valueProp],
+            label: option[valueProp],
+            obj: option
+          });
+        });
+        subscriber.next(resultOptions);
+        subscriber.complete();
+      } catch (error) {
+        subscriber.error(error);
+      }
+    });
+  }
+}
+
+export { JsonStringOptionPrivider, JsonVariable };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"JsonVariable.js","sources":["../../../../../src/variables/variants/JsonVariable.tsx"],"sourcesContent":["import React from 'react';\nimport { property } from 'lodash';\nimport { Observable, map, of } from 'rxjs';\n\nimport {\n  SceneComponentProps,\n  SceneObjectBase,\n  SceneVariable,\n  SceneVariableState,\n  SceneVariableValueChangedEvent,\n  ValidateAndUpdateResult,\n  VariableValue,\n} from '@grafana/scenes';\nimport { Select } from '@grafana/ui';\nimport { SelectableValue } from '@grafana/data';\n\nexport interface JsonVariableState extends SceneVariableState {\n  /**\n   * The current value\n   */\n  value?: string;\n  /**\n   * O\n   */\n  options: JsonVariableOption[];\n  /**\n   * The thing that generates/returns possible values / options\n   */\n  provider?: JsonVariableOptionProvider;\n}\n\nexport interface JsonVariableOption {\n  value: string;\n  label: string;\n  obj: unknown;\n}\n\nexport interface JsonVariableOptionProvider {\n  getOptions(): Observable<JsonVariableOption[]>;\n}\n\nexport class JsonVariable extends SceneObjectBase<JsonVariableState> implements SceneVariable {\n  public constructor(state: Partial<JsonVariableState>) {\n    super({\n      // @ts-ignore\n      type: 'json',\n      ...state,\n    });\n  }\n\n  private static fieldAccessorCache: FieldAccessorCache = {};\n\n  public validateAndUpdate(): Observable<ValidateAndUpdateResult> {\n    if (!this.state.provider) {\n      return of({});\n    }\n\n    return this.state.provider.getOptions().pipe(\n      map((options) => {\n        console.log('options', options);\n        this.updateValueGivenNewOptions(options);\n        return {};\n      })\n    );\n  }\n\n  private updateValueGivenNewOptions(options: JsonVariableOption[]) {\n    if (!this.state.value) {\n      return;\n    }\n\n    const stateUpdate: Partial<JsonVariableState> = { options };\n\n    const found = options.find((option) => option.value === this.state.value);\n\n    if (!found) {\n      if (options.length > 0) {\n        stateUpdate.value = options[0].value;\n      } else {\n        stateUpdate.value = undefined;\n      }\n    }\n\n    this.setState(stateUpdate);\n  }\n\n  public getValueText?(fieldPath?: string): string {\n    const current = this.state.options.find((option) => option.value === this.state.value);\n    return current ? current.label : '';\n  }\n\n  public getValue(fieldPath: string): VariableValue {\n    const current = this.state.options.find((option) => option.value === this.state.value);\n    return current ? this.getFieldAccessor(fieldPath)(current.obj) : '';\n  }\n\n  private getFieldAccessor(fieldPath: string) {\n    const accessor = JsonVariable.fieldAccessorCache[fieldPath];\n    if (accessor) {\n      return accessor;\n    }\n\n    return (JsonVariable.fieldAccessorCache[fieldPath] = property(fieldPath));\n  }\n\n  public _onChange = (selected: SelectableValue<string>) => {\n    this.setState({ value: selected.value });\n    this.publishEvent(new SceneVariableValueChangedEvent(this), true);\n  };\n\n  public static Component = ({ model }: SceneComponentProps<JsonVariable>) => {\n    const { key, value, options } = model.useState();\n\n    const current = options.find((option) => option.value === value)?.value;\n\n    return (\n      <Select\n        id={key}\n        placeholder=\"Select value\"\n        width=\"auto\"\n        value={current}\n        tabSelectsValue={false}\n        options={options}\n        onChange={model._onChange}\n      />\n    );\n  };\n}\n\ninterface FieldAccessorCache {\n  [key: string]: (obj: any) => any;\n}\n\nexport interface JsonStringOptionPrividerOptions {\n  /**\n   * String contauining JSON with an array of objects or a map of objects\n   */\n  json: string;\n  /**\n   * Defaults to name if not specified\n   */\n  valueProp?: string;\n}\n\nexport class JsonStringOptionPrivider implements JsonVariableOptionProvider {\n  public constructor(private options: JsonStringOptionPrividerOptions) {}\n\n  public getOptions(): Observable<JsonVariableOption[]> {\n    return new Observable((subscriber) => {\n      try {\n        const { json, valueProp = 'name' } = this.options;\n        const jsonValue = JSON.parse(json);\n\n        if (!Array.isArray(jsonValue)) {\n          throw new Error('JSON must be an array');\n        }\n\n        const resultOptions: JsonVariableOption[] = [];\n\n        jsonValue.forEach((option) => {\n          if (option[valueProp] == null) {\n            return;\n          }\n\n          resultOptions.push({\n            value: option[valueProp],\n            label: option[valueProp],\n            obj: option,\n          });\n        });\n\n        subscriber.next(resultOptions);\n        subscriber.complete();\n      } catch (error) {\n        subscriber.error(error);\n      }\n    });\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/src/variables/variants/LocalValueVariable.js

@@ -0,0 +1,56 @@
+import { SceneObjectBase } from '../../core/SceneObjectBase.js';
+import { sceneGraph } from '../../core/sceneGraph/index.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 LocalValueVariable extends SceneObjectBase {
+  constructor(initialState) {
+    super(__spreadProps(__spreadValues({
+      type: "system",
+      value: "",
+      text: "",
+      name: ""
+    }, initialState), {
+      skipUrlSync: true
+    }));
+  }
+  getValue() {
+    return this.state.value;
+  }
+  getValueText() {
+    return this.state.text.toString();
+  }
+  isAncestorLoading() {
+    var _a, _b;
+    const ancestorScope = (_b = (_a = this.parent) == null ? void 0 : _a.parent) == null ? void 0 : _b.parent;
+    if (!ancestorScope) {
+      throw new Error("LocalValueVariable requires a parent SceneVariableSet that has an ancestor SceneVariableSet");
+    }
+    const set = sceneGraph.getVariables(ancestorScope);
+    const parentVar = sceneGraph.lookupVariable(this.state.name, ancestorScope);
+    if (set && parentVar) {
+      return set.isVariableLoadingOrWaitingToUpdate(parentVar);
+    }
+    return false;
+  }
+}
+
+export { LocalValueVariable };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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