@grafana/scenes 6.7.0 → 6.8.0

package/dist/esm/src/variables/sets/SceneVariableSet.js

@@ -0,0 +1,254 @@
+import { VariableRefresh } from '@grafana/data';
+import { sceneGraph } from '../../core/sceneGraph/index.js';
+import { SceneObjectBase } from '../../core/SceneObjectBase.js';
+import { writeSceneLog } from '../../utils/writeSceneLog.js';
+import { SceneVariableValueChangedEvent } from '../types.js';
+import { VariableValueRecorder } from '../VariableValueRecorder.js';
+
+class SceneVariableSet extends SceneObjectBase {
+  constructor(state) {
+    super(state);
+    this._variablesThatHaveChanged = /* @__PURE__ */ new Set();
+    this._variablesToUpdate = /* @__PURE__ */ new Set();
+    this._updating = /* @__PURE__ */ new Map();
+    this._variableValueRecorder = new VariableValueRecorder();
+    this._variableDependency = new SceneVariableSetVariableDependencyHandler(
+      this._handleParentVariableUpdatesCompleted.bind(this)
+    );
+    this._onActivate = () => {
+      const timeRange = sceneGraph.getTimeRange(this);
+      this._subs.add(
+        this.subscribeToEvent(SceneVariableValueChangedEvent, (event) => this._handleVariableValueChanged(event.payload))
+      );
+      this._subs.add(
+        timeRange.subscribeToState(() => {
+          this._refreshTimeRangeBasedVariables();
+        })
+      );
+      this._subs.add(this.subscribeToState(this._onStateChanged));
+      this._checkForVariablesThatChangedWhileInactive();
+      for (const variable of this.state.variables) {
+        if (this._variableNeedsUpdate(variable)) {
+          this._variablesToUpdate.add(variable);
+        }
+      }
+      this._updateNextBatch();
+      return this._onDeactivate;
+    };
+    this._onDeactivate = () => {
+      var _a;
+      for (const update of this._updating.values()) {
+        (_a = update.subscription) == null ? void 0 : _a.unsubscribe();
+      }
+      for (const variable of this.state.variables) {
+        if (!this._variablesToUpdate.has(variable) && !this._updating.has(variable)) {
+          this._variableValueRecorder.recordCurrentValue(variable);
+        }
+      }
+      this._variablesToUpdate.clear();
+      this._updating.clear();
+    };
+    this._onStateChanged = (newState, oldState) => {
+      const variablesToUpdateCountStart = this._variablesToUpdate.size;
+      for (const variable of oldState.variables) {
+        if (!newState.variables.includes(variable)) {
+          const updating = this._updating.get(variable);
+          if (updating == null ? void 0 : updating.subscription) {
+            updating.subscription.unsubscribe();
+          }
+          this._updating.delete(variable);
+          this._variablesToUpdate.delete(variable);
+        }
+      }
+      for (const variable of newState.variables) {
+        if (!oldState.variables.includes(variable)) {
+          if (this._variableNeedsUpdate(variable)) {
+            this._variablesToUpdate.add(variable);
+          }
+        }
+      }
+      if (variablesToUpdateCountStart === 0 && this._variablesToUpdate.size > 0) {
+        this._updateNextBatch();
+      }
+    };
+    this.addActivationHandler(this._onActivate);
+  }
+  getByName(name) {
+    return this.state.variables.find((x) => x.state.name === name);
+  }
+  _refreshTimeRangeBasedVariables() {
+    for (const variable of this.state.variables) {
+      if ("refresh" in variable.state && variable.state.refresh === VariableRefresh.onTimeRangeChanged) {
+        this._variablesToUpdate.add(variable);
+      }
+    }
+    this._updateNextBatch();
+  }
+  _checkForVariablesThatChangedWhileInactive() {
+    if (!this._variableValueRecorder.hasValues()) {
+      return;
+    }
+    for (const variable of this.state.variables) {
+      if (this._variableValueRecorder.hasValueChanged(variable)) {
+        writeVariableTraceLog(variable, "Changed while in-active");
+        this._addDependentVariablesToUpdateQueue(variable);
+      }
+    }
+  }
+  _variableNeedsUpdate(variable) {
+    if (variable.isLazy) {
+      return false;
+    }
+    if (!variable.validateAndUpdate) {
+      return false;
+    }
+    if (this._variableValueRecorder.hasRecordedValue(variable)) {
+      writeVariableTraceLog(variable, "Skipping updateAndValidate current value valid");
+      return false;
+    }
+    return true;
+  }
+  _updateNextBatch() {
+    for (const variable of this._variablesToUpdate) {
+      if (!variable.validateAndUpdate) {
+        throw new Error("Variable added to variablesToUpdate but does not have validateAndUpdate");
+      }
+      if (this._updating.has(variable)) {
+        continue;
+      }
+      if (sceneGraph.hasVariableDependencyInLoadingState(variable)) {
+        continue;
+      }
+      const variableToUpdate = {
+        variable
+      };
+      this._updating.set(variable, variableToUpdate);
+      writeVariableTraceLog(variable, "updateAndValidate started");
+      variableToUpdate.subscription = variable.validateAndUpdate().subscribe({
+        next: () => this._validateAndUpdateCompleted(variable),
+        complete: () => this._validateAndUpdateCompleted(variable),
+        error: (err) => this._handleVariableError(variable, err)
+      });
+    }
+  }
+  _validateAndUpdateCompleted(variable) {
+    var _a;
+    if (!this._updating.has(variable)) {
+      return;
+    }
+    const update = this._updating.get(variable);
+    (_a = update == null ? void 0 : update.subscription) == null ? void 0 : _a.unsubscribe();
+    this._updating.delete(variable);
+    this._variablesToUpdate.delete(variable);
+    writeVariableTraceLog(variable, "updateAndValidate completed");
+    this._notifyDependentSceneObjects(variable);
+    this._updateNextBatch();
+  }
+  cancel(variable) {
+    var _a;
+    const update = this._updating.get(variable);
+    (_a = update == null ? void 0 : update.subscription) == null ? void 0 : _a.unsubscribe();
+    this._updating.delete(variable);
+    this._variablesToUpdate.delete(variable);
+  }
+  _handleVariableError(variable, err) {
+    var _a;
+    const update = this._updating.get(variable);
+    (_a = update == null ? void 0 : update.subscription) == null ? void 0 : _a.unsubscribe();
+    this._updating.delete(variable);
+    this._variablesToUpdate.delete(variable);
+    variable.setState({ loading: false, error: err.message });
+    console.error("SceneVariableSet updateAndValidate error", err);
+    writeVariableTraceLog(variable, "updateAndValidate error", err);
+    this._notifyDependentSceneObjects(variable);
+    this._updateNextBatch();
+  }
+  _handleVariableValueChanged(variableThatChanged) {
+    this._variablesThatHaveChanged.add(variableThatChanged);
+    this._addDependentVariablesToUpdateQueue(variableThatChanged);
+    if (!this._updating.has(variableThatChanged)) {
+      this._updateNextBatch();
+      this._notifyDependentSceneObjects(variableThatChanged);
+    }
+  }
+  _handleParentVariableUpdatesCompleted(variable, hasChanged) {
+    if (hasChanged) {
+      this._addDependentVariablesToUpdateQueue(variable);
+    }
+    if (this._variablesToUpdate.size > 0 && this._updating.size === 0) {
+      this._updateNextBatch();
+    }
+  }
+  _addDependentVariablesToUpdateQueue(variableThatChanged) {
+    for (const otherVariable of this.state.variables) {
+      if (otherVariable.variableDependency) {
+        if (otherVariable.variableDependency.hasDependencyOn(variableThatChanged.state.name)) {
+          writeVariableTraceLog(otherVariable, "Added to update queue, dependant variable value changed");
+          if (this._updating.has(otherVariable) && otherVariable.onCancel) {
+            otherVariable.onCancel();
+          }
+          this._variablesToUpdate.add(otherVariable);
+        }
+      }
+    }
+  }
+  _notifyDependentSceneObjects(variable) {
+    if (!this.parent) {
+      return;
+    }
+    this._traverseSceneAndNotify(this.parent, variable, this._variablesThatHaveChanged.has(variable));
+    this._variablesThatHaveChanged.delete(variable);
+  }
+  _traverseSceneAndNotify(sceneObject, variable, hasChanged) {
+    if (this === sceneObject) {
+      return;
+    }
+    if (!sceneObject.isActive) {
+      return;
+    }
+    if (sceneObject.state.$variables && sceneObject.state.$variables !== this) {
+      const localVar = sceneObject.state.$variables.getByName(variable.state.name);
+      if (localVar) {
+        return;
+      }
+    }
+    if (sceneObject.variableDependency) {
+      sceneObject.variableDependency.variableUpdateCompleted(variable, hasChanged);
+    }
+    sceneObject.forEachChild((child) => this._traverseSceneAndNotify(child, variable, hasChanged));
+  }
+  isVariableLoadingOrWaitingToUpdate(variable) {
+    if (variable.isAncestorLoading && variable.isAncestorLoading()) {
+      return true;
+    }
+    if (this._variablesToUpdate.has(variable) || this._updating.has(variable)) {
+      return true;
+    }
+    return sceneGraph.hasVariableDependencyInLoadingState(variable);
+  }
+}
+function writeVariableTraceLog(variable, message, err) {
+  if (err) {
+    writeSceneLog("SceneVariableSet", `Variable[${variable.state.name}]: ${message}`, err);
+  } else {
+    writeSceneLog("SceneVariableSet", `Variable[${variable.state.name}]: ${message}`);
+  }
+}
+class SceneVariableSetVariableDependencyHandler {
+  constructor(_variableUpdatesCompleted) {
+    this._variableUpdatesCompleted = _variableUpdatesCompleted;
+    this._emptySet = /* @__PURE__ */ new Set();
+  }
+  getNames() {
+    return this._emptySet;
+  }
+  hasDependencyOn(name) {
+    return false;
+  }
+  variableUpdateCompleted(variable, hasChanged) {
+    this._variableUpdatesCompleted(variable, hasChanged);
+  }
+}
+
+export { SceneVariableSet };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"SceneVariableSet.js","sources":["../../../../../src/variables/sets/SceneVariableSet.ts"],"sourcesContent":["import { VariableRefresh } from '@grafana/data';\nimport { Unsubscribable } from 'rxjs';\nimport { sceneGraph } from '../../core/sceneGraph';\n\nimport { SceneObjectBase } from '../../core/SceneObjectBase';\nimport { SceneObject } from '../../core/types';\nimport { writeSceneLog } from '../../utils/writeSceneLog';\nimport {\n  SceneVariable,\n  SceneVariableDependencyConfigLike,\n  SceneVariables,\n  SceneVariableSetState,\n  SceneVariableValueChangedEvent,\n} from '../types';\nimport { VariableValueRecorder } from '../VariableValueRecorder';\n\nexport class SceneVariableSet extends SceneObjectBase<SceneVariableSetState> implements SceneVariables {\n  /** Variables that have changed in since the activation or since the first manual value change */\n  private _variablesThatHaveChanged = new Set<SceneVariable>();\n\n  /** Variables that are scheduled to be validated and updated */\n  private _variablesToUpdate = new Set<SceneVariable>();\n\n  /** Variables currently updating  */\n  private _updating = new Map<SceneVariable, VariableUpdateInProgress>();\n\n  private _variableValueRecorder = new VariableValueRecorder();\n\n  /**\n   * This makes sure SceneVariableSet's higher up in the chain notify us when parent level variables complete update batches.\n   **/\n  protected _variableDependency = new SceneVariableSetVariableDependencyHandler(\n    this._handleParentVariableUpdatesCompleted.bind(this)\n  );\n\n  public getByName(name: string): SceneVariable | undefined {\n    // TODO: Replace with index\n    return this.state.variables.find((x) => x.state.name === name);\n  }\n\n  public constructor(state: SceneVariableSetState) {\n    super(state);\n\n    this.addActivationHandler(this._onActivate);\n  }\n\n  /**\n   * Subscribes to child variable value changes, and starts the variable value validation process\n   */\n  private _onActivate = () => {\n    const timeRange = sceneGraph.getTimeRange(this);\n    // Subscribe to changes to child variables\n    this._subs.add(\n      this.subscribeToEvent(SceneVariableValueChangedEvent, (event) => this._handleVariableValueChanged(event.payload))\n    );\n\n    this._subs.add(\n      timeRange.subscribeToState(() => {\n        this._refreshTimeRangeBasedVariables();\n      })\n    );\n\n    // Subscribe to state changes\n    this._subs.add(this.subscribeToState(this._onStateChanged));\n\n    this._checkForVariablesThatChangedWhileInactive();\n\n    // Add all variables that need updating to queue\n    for (const variable of this.state.variables) {\n      if (this._variableNeedsUpdate(variable)) {\n        this._variablesToUpdate.add(variable);\n      }\n    }\n\n    this._updateNextBatch();\n\n    // Return deactivation handler;\n    return this._onDeactivate;\n  };\n\n  /**\n   * Add all variables that depend on the changed variable to the update queue\n   */\n  private _refreshTimeRangeBasedVariables() {\n    for (const variable of this.state.variables) {\n      if ('refresh' in variable.state && variable.state.refresh === VariableRefresh.onTimeRangeChanged) {\n        this._variablesToUpdate.add(variable);\n      }\n    }\n    this._updateNextBatch();\n  }\n\n  /**\n   * Cancel all currently running updates\n   */\n  private _onDeactivate = () => {\n    for (const update of this._updating.values()) {\n      update.subscription?.unsubscribe();\n    }\n\n    // Remember current variable values\n    for (const variable of this.state.variables) {\n      // if the current variable is not in queue to update and validate and not being actively updated then the value is ok\n      if (!this._variablesToUpdate.has(variable) && !this._updating.has(variable)) {\n        this._variableValueRecorder.recordCurrentValue(variable);\n      }\n    }\n\n    this._variablesToUpdate.clear();\n    this._updating.clear();\n  };\n\n  /**\n   * Look for new variables that need to be initialized\n   */\n  private _onStateChanged = (newState: SceneVariableSetState, oldState: SceneVariableSetState) => {\n    const variablesToUpdateCountStart = this._variablesToUpdate.size;\n\n    // Check for removed variables\n    for (const variable of oldState.variables) {\n      if (!newState.variables.includes(variable)) {\n        const updating = this._updating.get(variable);\n        if (updating?.subscription) {\n          updating.subscription.unsubscribe();\n        }\n        this._updating.delete(variable);\n        this._variablesToUpdate.delete(variable);\n      }\n    }\n\n    // Check for new variables\n    for (const variable of newState.variables) {\n      if (!oldState.variables.includes(variable)) {\n        if (this._variableNeedsUpdate(variable)) {\n          this._variablesToUpdate.add(variable);\n        }\n      }\n    }\n\n    // Only start a new batch if there was no batch already running\n    if (variablesToUpdateCountStart === 0 && this._variablesToUpdate.size > 0) {\n      this._updateNextBatch();\n    }\n  };\n\n  /**\n   * If variables changed while in in-active state we don't get any change events, so we need to check for that here.\n   */\n  private _checkForVariablesThatChangedWhileInactive() {\n    if (!this._variableValueRecorder.hasValues()) {\n      return;\n    }\n\n    for (const variable of this.state.variables) {\n      if (this._variableValueRecorder.hasValueChanged(variable)) {\n        writeVariableTraceLog(variable, 'Changed while in-active');\n        this._addDependentVariablesToUpdateQueue(variable);\n      }\n    }\n  }\n\n  private _variableNeedsUpdate(variable: SceneVariable): boolean {\n    if (variable.isLazy) {\n      return false;\n    }\n\n    if (!variable.validateAndUpdate) {\n      return false;\n    }\n\n    // If we have recorded valid value (even if it has changed since we do not need to re-validate this variable)\n    if (this._variableValueRecorder.hasRecordedValue(variable)) {\n      writeVariableTraceLog(variable, 'Skipping updateAndValidate current value valid');\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * This loops through variablesToUpdate and update all that can.\n   * If one has a dependency that is currently in variablesToUpdate it will be skipped for now.\n   */\n  private _updateNextBatch() {\n    for (const variable of this._variablesToUpdate) {\n      if (!variable.validateAndUpdate) {\n        throw new Error('Variable added to variablesToUpdate but does not have validateAndUpdate');\n      }\n\n      // Ignore it if it's already started\n      if (this._updating.has(variable)) {\n        continue;\n      }\n\n      // Wait for variables that has dependencies that also needs updates\n      if (sceneGraph.hasVariableDependencyInLoadingState(variable)) {\n        continue;\n      }\n\n      const variableToUpdate: VariableUpdateInProgress = {\n        variable,\n      };\n\n      this._updating.set(variable, variableToUpdate);\n      writeVariableTraceLog(variable, 'updateAndValidate started');\n\n      variableToUpdate.subscription = variable.validateAndUpdate().subscribe({\n        next: () => this._validateAndUpdateCompleted(variable),\n        complete: () => this._validateAndUpdateCompleted(variable),\n        error: (err) => this._handleVariableError(variable, err),\n      });\n    }\n  }\n\n  /**\n   * A variable has completed its update process. This could mean that variables that depend on it can now be updated in turn.\n   */\n  private _validateAndUpdateCompleted(variable: SceneVariable) {\n    if (!this._updating.has(variable)) {\n      return;\n    }\n\n    const update = this._updating.get(variable);\n    update?.subscription?.unsubscribe();\n\n    this._updating.delete(variable);\n    this._variablesToUpdate.delete(variable);\n\n    writeVariableTraceLog(variable, 'updateAndValidate completed');\n\n    this._notifyDependentSceneObjects(variable);\n    this._updateNextBatch();\n  }\n\n  public cancel(variable: SceneVariable) {\n    const update = this._updating.get(variable);\n    update?.subscription?.unsubscribe();\n\n    this._updating.delete(variable);\n    this._variablesToUpdate.delete(variable);\n  }\n\n  private _handleVariableError(variable: SceneVariable, err: Error) {\n    const update = this._updating.get(variable);\n    update?.subscription?.unsubscribe();\n\n    this._updating.delete(variable);\n    this._variablesToUpdate.delete(variable);\n\n    variable.setState({ loading: false, error: err.message });\n\n    console.error('SceneVariableSet updateAndValidate error', err);\n\n    writeVariableTraceLog(variable, 'updateAndValidate error', err);\n\n    this._notifyDependentSceneObjects(variable);\n    this._updateNextBatch();\n  }\n\n  private _handleVariableValueChanged(variableThatChanged: SceneVariable) {\n    this._variablesThatHaveChanged.add(variableThatChanged);\n    this._addDependentVariablesToUpdateQueue(variableThatChanged);\n\n    // Ignore this change if it is currently updating\n    if (!this._updating.has(variableThatChanged)) {\n      this._updateNextBatch();\n      this._notifyDependentSceneObjects(variableThatChanged);\n    }\n  }\n\n  /**\n   * This is called by any parent level variable set to notify scene that an update batch is completed.\n   * This is the main mechanism lower level variable set's react to changes on higher levels.\n   */\n  private _handleParentVariableUpdatesCompleted(variable: SceneVariable, hasChanged: boolean) {\n    // First loop through changed variables and add any of our variables that depend on the higher level variable to the update queue\n    if (hasChanged) {\n      this._addDependentVariablesToUpdateQueue(variable);\n    }\n\n    // If we have variables to update but none are currently updating kick of a new update batch\n    if (this._variablesToUpdate.size > 0 && this._updating.size === 0) {\n      this._updateNextBatch();\n    }\n  }\n\n  private _addDependentVariablesToUpdateQueue(variableThatChanged: SceneVariable) {\n    for (const otherVariable of this.state.variables) {\n      if (otherVariable.variableDependency) {\n        if (otherVariable.variableDependency.hasDependencyOn(variableThatChanged.state.name)) {\n          writeVariableTraceLog(otherVariable, 'Added to update queue, dependant variable value changed');\n\n          if (this._updating.has(otherVariable) && otherVariable.onCancel) {\n            otherVariable.onCancel();\n          }\n\n          this._variablesToUpdate.add(otherVariable);\n        }\n      }\n    }\n  }\n\n  /**\n   * Walk scene object graph and update all objects that depend on variables that have changed\n   */\n  private _notifyDependentSceneObjects(variable: SceneVariable) {\n    if (!this.parent) {\n      return;\n    }\n\n    this._traverseSceneAndNotify(this.parent, variable, this._variablesThatHaveChanged.has(variable));\n    this._variablesThatHaveChanged.delete(variable);\n  }\n\n  /**\n   * Recursivly walk the full scene object graph and notify all objects with dependencies that include any of changed variables\n   */\n  private _traverseSceneAndNotify(sceneObject: SceneObject, variable: SceneVariable, hasChanged: boolean) {\n    // No need to notify variables under this SceneVariableSet\n    if (this === sceneObject) {\n      return;\n    }\n\n    // Skip non active scene objects\n    if (!sceneObject.isActive) {\n      return;\n    }\n\n    // If we find a nested SceneVariableSet that has a variable with the same name we stop the traversal\n    if (sceneObject.state.$variables && sceneObject.state.$variables !== this) {\n      const localVar = sceneObject.state.$variables.getByName(variable.state.name);\n      if (localVar) {\n        return;\n      }\n    }\n\n    if (sceneObject.variableDependency) {\n      sceneObject.variableDependency.variableUpdateCompleted(variable, hasChanged);\n    }\n\n    sceneObject.forEachChild((child) => this._traverseSceneAndNotify(child, variable, hasChanged));\n  }\n\n  /**\n   * Return true if variable is waiting to update or currently updating.\n   * It also returns true if a dependency of the variable is loading.\n   *\n   * For example if C depends on variable B which depends on variable A and A is loading this returns true for variable C and B.\n   */\n  public isVariableLoadingOrWaitingToUpdate(variable: SceneVariable) {\n    if (variable.isAncestorLoading && variable.isAncestorLoading()) {\n      return true;\n    }\n\n    if (this._variablesToUpdate.has(variable) || this._updating.has(variable)) {\n      return true;\n    }\n\n    // Last scenario is to check the variable's own dependencies as well\n    return sceneGraph.hasVariableDependencyInLoadingState(variable);\n  }\n}\n\nexport interface VariableUpdateInProgress {\n  variable: SceneVariable;\n  subscription?: Unsubscribable;\n}\n\nfunction writeVariableTraceLog(variable: SceneVariable, message: string, err?: Error) {\n  if (err) {\n    writeSceneLog('SceneVariableSet', `Variable[${variable.state.name}]: ${message}`, err);\n  } else {\n    writeSceneLog('SceneVariableSet', `Variable[${variable.state.name}]: ${message}`);\n  }\n}\n\nclass SceneVariableSetVariableDependencyHandler implements SceneVariableDependencyConfigLike {\n  public constructor(private _variableUpdatesCompleted: (variable: SceneVariable, hasChanged: boolean) => void) {}\n\n  private _emptySet = new Set<string>();\n\n  public getNames(): Set<string> {\n    return this._emptySet;\n  }\n\n  public hasDependencyOn(name: string): boolean {\n    return false;\n  }\n\n  public variableUpdateCompleted(variable: SceneVariable, hasChanged: boolean): void {\n    this._variableUpdatesCompleted(variable, hasChanged);\n  }\n}\n"],"names":[],"mappings":";;;;;;;AAgBO,MAAM,yBAAyB,eAAiE,CAAA;AAAA,EAwB9F,YAAY,KAA8B,EAAA;AAC/C,IAAA,KAAA,CAAM,KAAK,CAAA,CAAA;AAvBb,IAAQ,IAAA,CAAA,yBAAA,uBAAgC,GAAmB,EAAA,CAAA;AAG3D,IAAQ,IAAA,CAAA,kBAAA,uBAAyB,GAAmB,EAAA,CAAA;AAGpD,IAAQ,IAAA,CAAA,SAAA,uBAAgB,GAA6C,EAAA,CAAA;AAErE,IAAQ,IAAA,CAAA,sBAAA,GAAyB,IAAI,qBAAsB,EAAA,CAAA;AAK3D,IAAA,IAAA,CAAU,sBAAsB,IAAI,yCAAA;AAAA,MAClC,IAAA,CAAK,qCAAsC,CAAA,IAAA,CAAK,IAAI,CAAA;AAAA,KACtD,CAAA;AAgBA,IAAA,IAAA,CAAQ,cAAc,MAAM;AAC1B,MAAM,MAAA,SAAA,GAAY,UAAW,CAAA,YAAA,CAAa,IAAI,CAAA,CAAA;AAE9C,MAAA,IAAA,CAAK,KAAM,CAAA,GAAA;AAAA,QACT,IAAA,CAAK,iBAAiB,8BAAgC,EAAA,CAAC,UAAU,IAAK,CAAA,2BAAA,CAA4B,KAAM,CAAA,OAAO,CAAC,CAAA;AAAA,OAClH,CAAA;AAEA,MAAA,IAAA,CAAK,KAAM,CAAA,GAAA;AAAA,QACT,SAAA,CAAU,iBAAiB,MAAM;AAC/B,UAAA,IAAA,CAAK,+BAAgC,EAAA,CAAA;AAAA,SACtC,CAAA;AAAA,OACH,CAAA;AAGA,MAAA,IAAA,CAAK,MAAM,GAAI,CAAA,IAAA,CAAK,gBAAiB,CAAA,IAAA,CAAK,eAAe,CAAC,CAAA,CAAA;AAE1D,MAAA,IAAA,CAAK,0CAA2C,EAAA,CAAA;AAGhD,MAAW,KAAA,MAAA,QAAA,IAAY,IAAK,CAAA,KAAA,CAAM,SAAW,EAAA;AAC3C,QAAI,IAAA,IAAA,CAAK,oBAAqB,CAAA,QAAQ,CAAG,EAAA;AACvC,UAAK,IAAA,CAAA,kBAAA,CAAmB,IAAI,QAAQ,CAAA,CAAA;AAAA,SACtC;AAAA,OACF;AAEA,MAAA,IAAA,CAAK,gBAAiB,EAAA,CAAA;AAGtB,MAAA,OAAO,IAAK,CAAA,aAAA,CAAA;AAAA,KACd,CAAA;AAiBA,IAAA,IAAA,CAAQ,gBAAgB,MAAM;AA/FhC,MAAA,IAAA,EAAA,CAAA;AAgGI,MAAA,KAAA,MAAW,MAAU,IAAA,IAAA,CAAK,SAAU,CAAA,MAAA,EAAU,EAAA;AAC5C,QAAA,CAAA,EAAA,GAAA,MAAA,CAAO,iBAAP,IAAqB,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,WAAA,EAAA,CAAA;AAAA,OACvB;AAGA,MAAW,KAAA,MAAA,QAAA,IAAY,IAAK,CAAA,KAAA,CAAM,SAAW,EAAA;AAE3C,QAAI,IAAA,CAAC,IAAK,CAAA,kBAAA,CAAmB,GAAI,CAAA,QAAQ,CAAK,IAAA,CAAC,IAAK,CAAA,SAAA,CAAU,GAAI,CAAA,QAAQ,CAAG,EAAA;AAC3E,UAAK,IAAA,CAAA,sBAAA,CAAuB,mBAAmB,QAAQ,CAAA,CAAA;AAAA,SACzD;AAAA,OACF;AAEA,MAAA,IAAA,CAAK,mBAAmB,KAAM,EAAA,CAAA;AAC9B,MAAA,IAAA,CAAK,UAAU,KAAM,EAAA,CAAA;AAAA,KACvB,CAAA;AAKA,IAAQ,IAAA,CAAA,eAAA,GAAkB,CAAC,QAAA,EAAiC,QAAoC,KAAA;AAC9F,MAAM,MAAA,2BAAA,GAA8B,KAAK,kBAAmB,CAAA,IAAA,CAAA;AAG5D,MAAW,KAAA,MAAA,QAAA,IAAY,SAAS,SAAW,EAAA;AACzC,QAAA,IAAI,CAAC,QAAA,CAAS,SAAU,CAAA,QAAA,CAAS,QAAQ,CAAG,EAAA;AAC1C,UAAA,MAAM,QAAW,GAAA,IAAA,CAAK,SAAU,CAAA,GAAA,CAAI,QAAQ,CAAA,CAAA;AAC5C,UAAA,IAAI,qCAAU,YAAc,EAAA;AAC1B,YAAA,QAAA,CAAS,aAAa,WAAY,EAAA,CAAA;AAAA,WACpC;AACA,UAAK,IAAA,CAAA,SAAA,CAAU,OAAO,QAAQ,CAAA,CAAA;AAC9B,UAAK,IAAA,CAAA,kBAAA,CAAmB,OAAO,QAAQ,CAAA,CAAA;AAAA,SACzC;AAAA,OACF;AAGA,MAAW,KAAA,MAAA,QAAA,IAAY,SAAS,SAAW,EAAA;AACzC,QAAA,IAAI,CAAC,QAAA,CAAS,SAAU,CAAA,QAAA,CAAS,QAAQ,CAAG,EAAA;AAC1C,UAAI,IAAA,IAAA,CAAK,oBAAqB,CAAA,QAAQ,CAAG,EAAA;AACvC,YAAK,IAAA,CAAA,kBAAA,CAAmB,IAAI,QAAQ,CAAA,CAAA;AAAA,WACtC;AAAA,SACF;AAAA,OACF;AAGA,MAAA,IAAI,2BAAgC,KAAA,CAAA,IAAK,IAAK,CAAA,kBAAA,CAAmB,OAAO,CAAG,EAAA;AACzE,QAAA,IAAA,CAAK,gBAAiB,EAAA,CAAA;AAAA,OACxB;AAAA,KACF,CAAA;AApGE,IAAK,IAAA,CAAA,oBAAA,CAAqB,KAAK,WAAW,CAAA,CAAA;AAAA,GAC5C;AAAA,EATO,UAAU,IAAyC,EAAA;AAExD,IAAO,OAAA,IAAA,CAAK,MAAM,SAAU,CAAA,IAAA,CAAK,CAAC,CAAM,KAAA,CAAA,CAAE,KAAM,CAAA,IAAA,KAAS,IAAI,CAAA,CAAA;AAAA,GAC/D;AAAA,EA6CQ,+BAAkC,GAAA;AACxC,IAAW,KAAA,MAAA,QAAA,IAAY,IAAK,CAAA,KAAA,CAAM,SAAW,EAAA;AAC3C,MAAA,IAAI,aAAa,QAAS,CAAA,KAAA,IAAS,SAAS,KAAM,CAAA,OAAA,KAAY,gBAAgB,kBAAoB,EAAA;AAChG,QAAK,IAAA,CAAA,kBAAA,CAAmB,IAAI,QAAQ,CAAA,CAAA;AAAA,OACtC;AAAA,KACF;AACA,IAAA,IAAA,CAAK,gBAAiB,EAAA,CAAA;AAAA,GACxB;AAAA,EA0DQ,0CAA6C,GAAA;AACnD,IAAA,IAAI,CAAC,IAAA,CAAK,sBAAuB,CAAA,SAAA,EAAa,EAAA;AAC5C,MAAA,OAAA;AAAA,KACF;AAEA,IAAW,KAAA,MAAA,QAAA,IAAY,IAAK,CAAA,KAAA,CAAM,SAAW,EAAA;AAC3C,MAAA,IAAI,IAAK,CAAA,sBAAA,CAAuB,eAAgB,CAAA,QAAQ,CAAG,EAAA;AACzD,QAAA,qBAAA,CAAsB,UAAU,yBAAyB,CAAA,CAAA;AACzD,QAAA,IAAA,CAAK,oCAAoC,QAAQ,CAAA,CAAA;AAAA,OACnD;AAAA,KACF;AAAA,GACF;AAAA,EAEQ,qBAAqB,QAAkC,EAAA;AAC7D,IAAA,IAAI,SAAS,MAAQ,EAAA;AACnB,MAAO,OAAA,KAAA,CAAA;AAAA,KACT;AAEA,IAAI,IAAA,CAAC,SAAS,iBAAmB,EAAA;AAC/B,MAAO,OAAA,KAAA,CAAA;AAAA,KACT;AAGA,IAAA,IAAI,IAAK,CAAA,sBAAA,CAAuB,gBAAiB,CAAA,QAAQ,CAAG,EAAA;AAC1D,MAAA,qBAAA,CAAsB,UAAU,gDAAgD,CAAA,CAAA;AAChF,MAAO,OAAA,KAAA,CAAA;AAAA,KACT;AAEA,IAAO,OAAA,IAAA,CAAA;AAAA,GACT;AAAA,EAMQ,gBAAmB,GAAA;AACzB,IAAW,KAAA,MAAA,QAAA,IAAY,KAAK,kBAAoB,EAAA;AAC9C,MAAI,IAAA,CAAC,SAAS,iBAAmB,EAAA;AAC/B,QAAM,MAAA,IAAI,MAAM,yEAAyE,CAAA,CAAA;AAAA,OAC3F;AAGA,MAAA,IAAI,IAAK,CAAA,SAAA,CAAU,GAAI,CAAA,QAAQ,CAAG,EAAA;AAChC,QAAA,SAAA;AAAA,OACF;AAGA,MAAI,IAAA,UAAA,CAAW,mCAAoC,CAAA,QAAQ,CAAG,EAAA;AAC5D,QAAA,SAAA;AAAA,OACF;AAEA,MAAA,MAAM,gBAA6C,GAAA;AAAA,QACjD,QAAA;AAAA,OACF,CAAA;AAEA,MAAK,IAAA,CAAA,SAAA,CAAU,GAAI,CAAA,QAAA,EAAU,gBAAgB,CAAA,CAAA;AAC7C,MAAA,qBAAA,CAAsB,UAAU,2BAA2B,CAAA,CAAA;AAE3D,MAAA,gBAAA,CAAiB,YAAe,GAAA,QAAA,CAAS,iBAAkB,EAAA,CAAE,SAAU,CAAA;AAAA,QACrE,IAAM,EAAA,MAAM,IAAK,CAAA,2BAAA,CAA4B,QAAQ,CAAA;AAAA,QACrD,QAAU,EAAA,MAAM,IAAK,CAAA,2BAAA,CAA4B,QAAQ,CAAA;AAAA,QACzD,OAAO,CAAC,GAAA,KAAQ,IAAK,CAAA,oBAAA,CAAqB,UAAU,GAAG,CAAA;AAAA,OACxD,CAAA,CAAA;AAAA,KACH;AAAA,GACF;AAAA,EAKQ,4BAA4B,QAAyB,EAAA;AAzN/D,IAAA,IAAA,EAAA,CAAA;AA0NI,IAAA,IAAI,CAAC,IAAA,CAAK,SAAU,CAAA,GAAA,CAAI,QAAQ,CAAG,EAAA;AACjC,MAAA,OAAA;AAAA,KACF;AAEA,IAAA,MAAM,MAAS,GAAA,IAAA,CAAK,SAAU,CAAA,GAAA,CAAI,QAAQ,CAAA,CAAA;AAC1C,IAAA,CAAA,EAAA,GAAA,MAAA,IAAA,IAAA,GAAA,KAAA,CAAA,GAAA,MAAA,CAAQ,iBAAR,IAAsB,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,WAAA,EAAA,CAAA;AAEtB,IAAK,IAAA,CAAA,SAAA,CAAU,OAAO,QAAQ,CAAA,CAAA;AAC9B,IAAK,IAAA,CAAA,kBAAA,CAAmB,OAAO,QAAQ,CAAA,CAAA;AAEvC,IAAA,qBAAA,CAAsB,UAAU,6BAA6B,CAAA,CAAA;AAE7D,IAAA,IAAA,CAAK,6BAA6B,QAAQ,CAAA,CAAA;AAC1C,IAAA,IAAA,CAAK,gBAAiB,EAAA,CAAA;AAAA,GACxB;AAAA,EAEO,OAAO,QAAyB,EAAA;AA1OzC,IAAA,IAAA,EAAA,CAAA;AA2OI,IAAA,MAAM,MAAS,GAAA,IAAA,CAAK,SAAU,CAAA,GAAA,CAAI,QAAQ,CAAA,CAAA;AAC1C,IAAA,CAAA,EAAA,GAAA,MAAA,IAAA,IAAA,GAAA,KAAA,CAAA,GAAA,MAAA,CAAQ,iBAAR,IAAsB,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,WAAA,EAAA,CAAA;AAEtB,IAAK,IAAA,CAAA,SAAA,CAAU,OAAO,QAAQ,CAAA,CAAA;AAC9B,IAAK,IAAA,CAAA,kBAAA,CAAmB,OAAO,QAAQ,CAAA,CAAA;AAAA,GACzC;AAAA,EAEQ,oBAAA,CAAqB,UAAyB,GAAY,EAAA;AAlPpE,IAAA,IAAA,EAAA,CAAA;AAmPI,IAAA,MAAM,MAAS,GAAA,IAAA,CAAK,SAAU,CAAA,GAAA,CAAI,QAAQ,CAAA,CAAA;AAC1C,IAAA,CAAA,EAAA,GAAA,MAAA,IAAA,IAAA,GAAA,KAAA,CAAA,GAAA,MAAA,CAAQ,iBAAR,IAAsB,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,WAAA,EAAA,CAAA;AAEtB,IAAK,IAAA,CAAA,SAAA,CAAU,OAAO,QAAQ,CAAA,CAAA;AAC9B,IAAK,IAAA,CAAA,kBAAA,CAAmB,OAAO,QAAQ,CAAA,CAAA;AAEvC,IAAA,QAAA,CAAS,SAAS,EAAE,OAAA,EAAS,OAAO,KAAO,EAAA,GAAA,CAAI,SAAS,CAAA,CAAA;AAExD,IAAQ,OAAA,CAAA,KAAA,CAAM,4CAA4C,GAAG,CAAA,CAAA;AAE7D,IAAsB,qBAAA,CAAA,QAAA,EAAU,2BAA2B,GAAG,CAAA,CAAA;AAE9D,IAAA,IAAA,CAAK,6BAA6B,QAAQ,CAAA,CAAA;AAC1C,IAAA,IAAA,CAAK,gBAAiB,EAAA,CAAA;AAAA,GACxB;AAAA,EAEQ,4BAA4B,mBAAoC,EAAA;AACtE,IAAK,IAAA,CAAA,yBAAA,CAA0B,IAAI,mBAAmB,CAAA,CAAA;AACtD,IAAA,IAAA,CAAK,oCAAoC,mBAAmB,CAAA,CAAA;AAG5D,IAAA,IAAI,CAAC,IAAA,CAAK,SAAU,CAAA,GAAA,CAAI,mBAAmB,CAAG,EAAA;AAC5C,MAAA,IAAA,CAAK,gBAAiB,EAAA,CAAA;AACtB,MAAA,IAAA,CAAK,6BAA6B,mBAAmB,CAAA,CAAA;AAAA,KACvD;AAAA,GACF;AAAA,EAMQ,qCAAA,CAAsC,UAAyB,UAAqB,EAAA;AAE1F,IAAA,IAAI,UAAY,EAAA;AACd,MAAA,IAAA,CAAK,oCAAoC,QAAQ,CAAA,CAAA;AAAA,KACnD;AAGA,IAAA,IAAI,KAAK,kBAAmB,CAAA,IAAA,GAAO,KAAK,IAAK,CAAA,SAAA,CAAU,SAAS,CAAG,EAAA;AACjE,MAAA,IAAA,CAAK,gBAAiB,EAAA,CAAA;AAAA,KACxB;AAAA,GACF;AAAA,EAEQ,oCAAoC,mBAAoC,EAAA;AAC9E,IAAW,KAAA,MAAA,aAAA,IAAiB,IAAK,CAAA,KAAA,CAAM,SAAW,EAAA;AAChD,MAAA,IAAI,cAAc,kBAAoB,EAAA;AACpC,QAAA,IAAI,cAAc,kBAAmB,CAAA,eAAA,CAAgB,mBAAoB,CAAA,KAAA,CAAM,IAAI,CAAG,EAAA;AACpF,UAAA,qBAAA,CAAsB,eAAe,yDAAyD,CAAA,CAAA;AAE9F,UAAA,IAAI,KAAK,SAAU,CAAA,GAAA,CAAI,aAAa,CAAA,IAAK,cAAc,QAAU,EAAA;AAC/D,YAAA,aAAA,CAAc,QAAS,EAAA,CAAA;AAAA,WACzB;AAEA,UAAK,IAAA,CAAA,kBAAA,CAAmB,IAAI,aAAa,CAAA,CAAA;AAAA,SAC3C;AAAA,OACF;AAAA,KACF;AAAA,GACF;AAAA,EAKQ,6BAA6B,QAAyB,EAAA;AAC5D,IAAI,IAAA,CAAC,KAAK,MAAQ,EAAA;AAChB,MAAA,OAAA;AAAA,KACF;AAEA,IAAK,IAAA,CAAA,uBAAA,CAAwB,KAAK,MAAQ,EAAA,QAAA,EAAU,KAAK,yBAA0B,CAAA,GAAA,CAAI,QAAQ,CAAC,CAAA,CAAA;AAChG,IAAK,IAAA,CAAA,yBAAA,CAA0B,OAAO,QAAQ,CAAA,CAAA;AAAA,GAChD;AAAA,EAKQ,uBAAA,CAAwB,WAA0B,EAAA,QAAA,EAAyB,UAAqB,EAAA;AAEtG,IAAA,IAAI,SAAS,WAAa,EAAA;AACxB,MAAA,OAAA;AAAA,KACF;AAGA,IAAI,IAAA,CAAC,YAAY,QAAU,EAAA;AACzB,MAAA,OAAA;AAAA,KACF;AAGA,IAAA,IAAI,YAAY,KAAM,CAAA,UAAA,IAAc,WAAY,CAAA,KAAA,CAAM,eAAe,IAAM,EAAA;AACzE,MAAA,MAAM,WAAW,WAAY,CAAA,KAAA,CAAM,WAAW,SAAU,CAAA,QAAA,CAAS,MAAM,IAAI,CAAA,CAAA;AAC3E,MAAA,IAAI,QAAU,EAAA;AACZ,QAAA,OAAA;AAAA,OACF;AAAA,KACF;AAEA,IAAA,IAAI,YAAY,kBAAoB,EAAA;AAClC,MAAY,WAAA,CAAA,kBAAA,CAAmB,uBAAwB,CAAA,QAAA,EAAU,UAAU,CAAA,CAAA;AAAA,KAC7E;AAEA,IAAY,WAAA,CAAA,YAAA,CAAa,CAAC,KAAU,KAAA,IAAA,CAAK,wBAAwB,KAAO,EAAA,QAAA,EAAU,UAAU,CAAC,CAAA,CAAA;AAAA,GAC/F;AAAA,EAQO,mCAAmC,QAAyB,EAAA;AACjE,IAAA,IAAI,QAAS,CAAA,iBAAA,IAAqB,QAAS,CAAA,iBAAA,EAAqB,EAAA;AAC9D,MAAO,OAAA,IAAA,CAAA;AAAA,KACT;AAEA,IAAI,IAAA,IAAA,CAAK,mBAAmB,GAAI,CAAA,QAAQ,KAAK,IAAK,CAAA,SAAA,CAAU,GAAI,CAAA,QAAQ,CAAG,EAAA;AACzE,MAAO,OAAA,IAAA,CAAA;AAAA,KACT;AAGA,IAAO,OAAA,UAAA,CAAW,oCAAoC,QAAQ,CAAA,CAAA;AAAA,GAChE;AACF,CAAA;AAOA,SAAS,qBAAA,CAAsB,QAAyB,EAAA,OAAA,EAAiB,GAAa,EAAA;AACpF,EAAA,IAAI,GAAK,EAAA;AACP,IAAA,aAAA,CAAc,oBAAoB,CAAY,SAAA,EAAA,QAAA,CAAS,KAAM,CAAA,IAAA,CAAA,GAAA,EAAU,WAAW,GAAG,CAAA,CAAA;AAAA,GAChF,MAAA;AACL,IAAA,aAAA,CAAc,kBAAoB,EAAA,CAAA,SAAA,EAAY,QAAS,CAAA,KAAA,CAAM,UAAU,OAAS,CAAA,CAAA,CAAA,CAAA;AAAA,GAClF;AACF,CAAA;AAEA,MAAM,yCAAuF,CAAA;AAAA,EACpF,YAAoB,yBAAmF,EAAA;AAAnF,IAAA,IAAA,CAAA,yBAAA,GAAA,yBAAA,CAAA;AAE3B,IAAQ,IAAA,CAAA,SAAA,uBAAgB,GAAY,EAAA,CAAA;AAAA,GAF2E;AAAA,EAIxG,QAAwB,GAAA;AAC7B,IAAA,OAAO,IAAK,CAAA,SAAA,CAAA;AAAA,GACd;AAAA,EAEO,gBAAgB,IAAuB,EAAA;AAC5C,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAAA,EAEO,uBAAA,CAAwB,UAAyB,UAA2B,EAAA;AACjF,IAAK,IAAA,CAAA,yBAAA,CAA0B,UAAU,UAAU,CAAA,CAAA;AAAA,GACrD;AACF;;;;"}

package/dist/esm/src/variables/types.js

@@ -0,0 +1,11 @@
+import { BusEventWithPayload } from '@grafana/data';
+
+class SceneVariableValueChangedEvent extends BusEventWithPayload {
+}
+SceneVariableValueChangedEvent.type = "scene-variable-changed-value";
+function isCustomVariableValue(value) {
+  return typeof value === "object" && "formatter" in value;
+}
+
+export { SceneVariableValueChangedEvent, isCustomVariableValue };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,172 @@
+import { isEqual } from 'lodash';
+import { sceneGraph } from '../core/sceneGraph/index.js';
+import { SceneQueryRunner } from '../querying/SceneQueryRunner.js';
+import uFuzzy from '@leeoniya/ufuzzy';
+
+function isVariableValueEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  return isEqual(a, b);
+}
+function safeStringifyValue(value) {
+  const getCircularReplacer = () => {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return (_, value2) => {
+      if (typeof value2 === "object" && value2 !== null) {
+        if (seen.has(value2)) {
+          return;
+        }
+        seen.add(value2);
+      }
+      return value2;
+    };
+  };
+  try {
+    return JSON.stringify(value, getCircularReplacer());
+  } catch (error) {
+    console.error(error);
+  }
+  return "";
+}
+function renderPrometheusLabelFilters(filters) {
+  return filters.map((filter) => renderFilter(filter)).join(",");
+}
+function renderFilter(filter) {
+  var _a, _b;
+  let value = "";
+  let operator = filter.operator;
+  if (operator === "=|") {
+    operator = "=~";
+    value = (_a = filter.values) == null ? void 0 : _a.map(escapeLabelValueInRegexSelector).join("|");
+  } else if (operator === "!=|") {
+    operator = "!~";
+    value = (_b = filter.values) == null ? void 0 : _b.map(escapeLabelValueInRegexSelector).join("|");
+  } else if (operator === "=~" || operator === "!~") {
+    value = escapeLabelValueInRegexSelector(filter.value);
+  } else {
+    value = escapeLabelValueInExactSelector(filter.value);
+  }
+  return `${filter.key}${operator}"${value}"`;
+}
+function escapeLabelValueInExactSelector(labelValue) {
+  return labelValue.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, '\\"');
+}
+function escapeLabelValueInRegexSelector(labelValue) {
+  return escapeLabelValueInExactSelector(escapeLokiRegexp(labelValue));
+}
+const RE2_METACHARACTERS = /[*+?()|\\.\[\]{}^$]/g;
+function escapeLokiRegexp(value) {
+  return value.replace(RE2_METACHARACTERS, "\\$&");
+}
+function getQueriesForVariables(sourceObject) {
+  const runners = sceneGraph.findAllObjects(
+    sourceObject.getRoot(),
+    (o) => o instanceof SceneQueryRunner
+  );
+  const applicableRunners = filterOutInactiveRunnerDuplicates(runners).filter((r) => {
+    var _a, _b;
+    return ((_a = r.state.datasource) == null ? void 0 : _a.uid) === ((_b = sourceObject.state.datasource) == null ? void 0 : _b.uid);
+  });
+  if (applicableRunners.length === 0) {
+    return [];
+  }
+  const result = [];
+  applicableRunners.forEach((r) => {
+    result.push(...r.state.queries);
+  });
+  return result;
+}
+function filterOutInactiveRunnerDuplicates(runners) {
+  const groupedItems = {};
+  for (const item of runners) {
+    if (item.state.key) {
+      if (!(item.state.key in groupedItems)) {
+        groupedItems[item.state.key] = [];
+      }
+      groupedItems[item.state.key].push(item);
+    }
+  }
+  return Object.values(groupedItems).flatMap((group) => {
+    const activeItems = group.filter((item) => item.isActive);
+    if (activeItems.length === 0 && group.length === 1) {
+      return group;
+    }
+    return activeItems;
+  });
+}
+function escapeUrlPipeDelimiters(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  return value = /\|/g[Symbol.replace](value, "__gfp__");
+}
+function escapeUrlCommaDelimiters(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  return /,/g[Symbol.replace](value, "__gfc__");
+}
+function unescapeUrlDelimiters(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  value = /__gfp__/g[Symbol.replace](value, "|");
+  value = /__gfc__/g[Symbol.replace](value, ",");
+  return value;
+}
+function toUrlCommaDelimitedString(key, label) {
+  if (!label || key === label) {
+    return escapeUrlCommaDelimiters(key);
+  }
+  return [key, label].map(escapeUrlCommaDelimiters).join(",");
+}
+function dataFromResponse(response) {
+  return Array.isArray(response) ? response : response.data;
+}
+function responseHasError(response) {
+  return !Array.isArray(response) && Boolean(response.error);
+}
+function handleOptionGroups(values) {
+  const result = [];
+  const groupedResults = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const groupLabel = value.group;
+    if (groupLabel) {
+      let group = groupedResults.get(groupLabel);
+      if (!group) {
+        group = [];
+        groupedResults.set(groupLabel, group);
+        result.push({ label: groupLabel, options: group });
+      }
+      group.push(value);
+    } else {
+      result.push(value);
+    }
+  }
+  return result;
+}
+function getFuzzySearcher(haystack, limit = 1e4) {
+  const ufuzzy = new uFuzzy();
+  const FIRST = Array.from({ length: Math.min(limit, haystack.length) }, (_, i) => i);
+  return (search) => {
+    if (search === "") {
+      return FIRST;
+    }
+    const [idxs, info, order] = ufuzzy.search(haystack, search);
+    if (idxs) {
+      if (info && order) {
+        const outIdxs = Array(Math.min(order.length, limit));
+        for (let i = 0; i < outIdxs.length; i++) {
+          outIdxs[i] = info.idx[order[i]];
+        }
+        return outIdxs;
+      }
+      return idxs.slice(0, limit);
+    }
+    return [];
+  };
+}
+
+export { dataFromResponse, escapeLabelValueInExactSelector, escapeLabelValueInRegexSelector, escapeUrlCommaDelimiters, escapeUrlPipeDelimiters, getFuzzySearcher, getQueriesForVariables, handleOptionGroups, isVariableValueEqual, renderPrometheusLabelFilters, responseHasError, safeStringifyValue, toUrlCommaDelimitedString, unescapeUrlDelimiters };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"utils.js","sources":["../../../../src/variables/utils.ts"],"sourcesContent":["import { isEqual } from 'lodash';\nimport { VariableValue } from './types';\nimport { AdHocVariableFilter, DataQueryError, GetTagResponse, MetricFindValue, SelectableValue } from '@grafana/data';\nimport { sceneGraph } from '../core/sceneGraph';\nimport { SceneDataQuery, SceneObject, SceneObjectState } from '../core/types';\nimport { SceneQueryRunner } from '../querying/SceneQueryRunner';\nimport { DataSourceRef } from '@grafana/schema';\nimport uFuzzy from '@leeoniya/ufuzzy';\n\nexport function isVariableValueEqual(a: VariableValue | null | undefined, b: VariableValue | null | undefined) {\n  if (a === b) {\n    return true;\n  }\n\n  return isEqual(a, b);\n}\n\nexport function safeStringifyValue(value: unknown) {\n  // Avoid circular references ignoring those references\n  const getCircularReplacer = () => {\n    const seen = new WeakSet();\n    return (_: string, value: object | null) => {\n      if (typeof value === 'object' && value !== null) {\n        if (seen.has(value)) {\n          return;\n        }\n        seen.add(value);\n      }\n      return value;\n    };\n  };\n\n  try {\n    return JSON.stringify(value, getCircularReplacer());\n  } catch (error) {\n    console.error(error);\n  }\n\n  return '';\n}\n\nexport function renderPrometheusLabelFilters(filters: AdHocVariableFilter[]) {\n  return filters.map((filter) => renderFilter(filter)).join(',');\n}\n\nfunction renderFilter(filter: AdHocVariableFilter) {\n  let value = '';\n  let operator = filter.operator;\n\n  // map \"one of\" operator to regex\n  if (operator === '=|') {\n    operator = '=~';\n    // TODO remove when we're on the latest version of @grafana/data\n    // @ts-expect-error\n    value = filter.values?.map(escapeLabelValueInRegexSelector).join('|');\n  } else if (operator === '!=|') {\n    operator = '!~';\n    // TODO remove when we're on the latest version of @grafana/data\n    // @ts-expect-error\n    value = filter.values?.map(escapeLabelValueInRegexSelector).join('|');\n  } else if (operator === '=~' || operator === '!~') {\n    value = escapeLabelValueInRegexSelector(filter.value);\n  } else {\n    value = escapeLabelValueInExactSelector(filter.value);\n  }\n\n  return `${filter.key}${operator}\"${value}\"`;\n}\n\n// based on the openmetrics-documentation, the 3 symbols we have to handle are:\n// - \\n ... the newline character\n// - \\  ... the backslash character\n// - \"  ... the double-quote character\nexport function escapeLabelValueInExactSelector(labelValue: string): string {\n  return labelValue.replace(/\\\\/g, '\\\\\\\\').replace(/\\n/g, '\\\\n').replace(/\"/g, '\\\\\"');\n}\n\nexport function escapeLabelValueInRegexSelector(labelValue: string): string {\n  return escapeLabelValueInExactSelector(escapeLokiRegexp(labelValue));\n}\n\nexport function isRegexSelector(selector?: string) {\n  if (selector && (selector.includes('=~') || selector.includes('!~'))) {\n    return true;\n  }\n  return false;\n}\n\n// Loki regular-expressions use the RE2 syntax (https://github.com/google/re2/wiki/Syntax),\n// so every character that matches something in that list has to be escaped.\n// the list of meta characters is: *+?()|\\.[]{}^$\n// we make a javascript regular expression that matches those characters:\nconst RE2_METACHARACTERS = /[*+?()|\\\\.\\[\\]{}^$]/g;\nfunction escapeLokiRegexp(value: string): string {\n  return value.replace(RE2_METACHARACTERS, '\\\\$&');\n}\n\n/**\n * Get all queries in the scene that have the same datasource as provided source object\n */\nexport function getQueriesForVariables(\n  sourceObject: SceneObject<SceneObjectState & { datasource: DataSourceRef | null }>\n) {\n  const runners = sceneGraph.findAllObjects(\n    sourceObject.getRoot(),\n    (o) => o instanceof SceneQueryRunner\n  ) as SceneQueryRunner[];\n\n  const applicableRunners = filterOutInactiveRunnerDuplicates(runners).filter((r) => {\n    return r.state.datasource?.uid === sourceObject.state.datasource?.uid;\n  });\n\n  if (applicableRunners.length === 0) {\n    return [];\n  }\n\n  const result: SceneDataQuery[] = [];\n  applicableRunners.forEach((r) => {\n    result.push(...r.state.queries);\n  });\n\n  return result;\n}\n\n// Filters out inactive runner duplicates, keeping only the ones that are currently active.\n// This is needed for scnearios whan a query runner is cloned and the original is not removed but de-activated.\n// Can happen i.e. when editing a panel in Grafana Core dashboards.\nfunction filterOutInactiveRunnerDuplicates(runners: SceneQueryRunner[]) {\n  // Group items by key\n  const groupedItems: { [key: string]: SceneQueryRunner[] } = {};\n\n  for (const item of runners) {\n    if (item.state.key) {\n      if (!(item.state.key in groupedItems)) {\n        groupedItems[item.state.key] = [];\n      }\n      groupedItems[item.state.key].push(item);\n    }\n  }\n\n  // Filter out inactive items and concatenate active items\n  return Object.values(groupedItems).flatMap((group) => {\n    const activeItems = group.filter((item) => item.isActive);\n    // Keep inactive items if there's only one item with the key\n    if (activeItems.length === 0 && group.length === 1) {\n      return group;\n    }\n    return activeItems;\n  });\n}\n\nexport function escapeUrlPipeDelimiters(value: string | undefined): string {\n  if (value === null || value === undefined) {\n    return '';\n  }\n\n  // Replace the pipe due to using it as a filter separator\n  return (value = /\\|/g[Symbol.replace](value, '__gfp__'));\n}\n\nexport function escapeUrlCommaDelimiters(value: string | undefined): string {\n  if (value === null || value === undefined) {\n    return '';\n  }\n\n  // Replace the comma due to using it as a value/label separator\n  return /,/g[Symbol.replace](value, '__gfc__');\n}\n\nexport function unescapeUrlDelimiters(value: string | undefined): string {\n  if (value === null || value === undefined) {\n    return '';\n  }\n\n  value = /__gfp__/g[Symbol.replace](value, '|');\n  value = /__gfc__/g[Symbol.replace](value, ',');\n\n  return value;\n}\n\nexport function toUrlCommaDelimitedString(key: string, label?: string): string {\n  // Omit for identical key/label or when label is not set at all\n  if (!label || key === label) {\n    return escapeUrlCommaDelimiters(key);\n  }\n\n  return [key, label].map(escapeUrlCommaDelimiters).join(',');\n}\n\nexport function dataFromResponse(response: GetTagResponse | MetricFindValue[]) {\n  return Array.isArray(response) ? response : response.data;\n}\n\nexport function responseHasError(\n  response: GetTagResponse | MetricFindValue[]\n): response is GetTagResponse & { error: DataQueryError } {\n  return !Array.isArray(response) && Boolean(response.error);\n}\n\n// Collect a flat list of SelectableValues with a `group` property into a hierarchical list with groups\nexport function handleOptionGroups(values: SelectableValue[]): Array<SelectableValue<string>> {\n  const result: Array<SelectableValue<string>> = [];\n  const groupedResults = new Map<string, Array<SelectableValue<string>>>();\n\n  for (const value of values) {\n    const groupLabel = value.group;\n    if (groupLabel) {\n      let group = groupedResults.get(groupLabel);\n\n      if (!group) {\n        group = [];\n        groupedResults.set(groupLabel, group);\n        result.push({ label: groupLabel, options: group });\n      }\n\n      group.push(value);\n    } else {\n      result.push(value);\n    }\n  }\n\n  return result;\n}\n\nexport function getFuzzySearcher(haystack: string[], limit = 10_000) {\n  const ufuzzy = new uFuzzy();\n\n  const FIRST = Array.from({ length: Math.min(limit, haystack.length) }, (_, i) => i);\n\n  // returns matched indices by quality\n  return (search: string): number[] => {\n    if (search === '') {\n      return FIRST;\n    }\n\n    const [idxs, info, order] = ufuzzy.search(haystack, search);\n\n    if (idxs) {\n      if (info && order) {\n        const outIdxs = Array(Math.min(order.length, limit));\n\n        for (let i = 0; i < outIdxs.length; i++) {\n          outIdxs[i] = info.idx[order[i]];\n        }\n\n        return outIdxs;\n      }\n\n      return idxs.slice(0, limit);\n    }\n\n    return [];\n  };\n}\n"],"names":["value"],"mappings":";;;;;AASgB,SAAA,oBAAA,CAAqB,GAAqC,CAAqC,EAAA;AAC7G,EAAA,IAAI,MAAM,CAAG,EAAA;AACX,IAAO,OAAA,IAAA,CAAA;AAAA,GACT;AAEA,EAAO,OAAA,OAAA,CAAQ,GAAG,CAAC,CAAA,CAAA;AACrB,CAAA;AAEO,SAAS,mBAAmB,KAAgB,EAAA;AAEjD,EAAA,MAAM,sBAAsB,MAAM;AAChC,IAAM,MAAA,IAAA,uBAAW,OAAQ,EAAA,CAAA;AACzB,IAAO,OAAA,CAAC,GAAWA,MAAyB,KAAA;AAC1C,MAAA,IAAI,OAAOA,MAAAA,KAAU,QAAYA,IAAAA,MAAAA,KAAU,IAAM,EAAA;AAC/C,QAAI,IAAA,IAAA,CAAK,GAAIA,CAAAA,MAAK,CAAG,EAAA;AACnB,UAAA,OAAA;AAAA,SACF;AACA,QAAA,IAAA,CAAK,IAAIA,MAAK,CAAA,CAAA;AAAA,OAChB;AACA,MAAOA,OAAAA,MAAAA,CAAAA;AAAA,KACT,CAAA;AAAA,GACF,CAAA;AAEA,EAAI,IAAA;AACF,IAAA,OAAO,IAAK,CAAA,SAAA,CAAU,KAAO,EAAA,mBAAA,EAAqB,CAAA,CAAA;AAAA,WAC3C,KAAP,EAAA;AACA,IAAA,OAAA,CAAQ,MAAM,KAAK,CAAA,CAAA;AAAA,GACrB;AAEA,EAAO,OAAA,EAAA,CAAA;AACT,CAAA;AAEO,SAAS,6BAA6B,OAAgC,EAAA;AAC3E,EAAO,OAAA,OAAA,CAAQ,IAAI,CAAC,MAAA,KAAW,aAAa,MAAM,CAAC,CAAE,CAAA,IAAA,CAAK,GAAG,CAAA,CAAA;AAC/D,CAAA;AAEA,SAAS,aAAa,MAA6B,EAAA;AA7CnD,EAAA,IAAA,EAAA,EAAA,EAAA,CAAA;AA8CE,EAAA,IAAI,KAAQ,GAAA,EAAA,CAAA;AACZ,EAAA,IAAI,WAAW,MAAO,CAAA,QAAA,CAAA;AAGtB,EAAA,IAAI,aAAa,IAAM,EAAA;AACrB,IAAW,QAAA,GAAA,IAAA,CAAA;AAGX,IAAA,KAAA,GAAA,CAAQ,EAAO,GAAA,MAAA,CAAA,MAAA,KAAP,IAAe,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,GAAA,CAAI,iCAAiC,IAAK,CAAA,GAAA,CAAA,CAAA;AAAA,GACnE,MAAA,IAAW,aAAa,KAAO,EAAA;AAC7B,IAAW,QAAA,GAAA,IAAA,CAAA;AAGX,IAAA,KAAA,GAAA,CAAQ,EAAO,GAAA,MAAA,CAAA,MAAA,KAAP,IAAe,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,GAAA,CAAI,iCAAiC,IAAK,CAAA,GAAA,CAAA,CAAA;AAAA,GACxD,MAAA,IAAA,QAAA,KAAa,IAAQ,IAAA,QAAA,KAAa,IAAM,EAAA;AACjD,IAAQ,KAAA,GAAA,+BAAA,CAAgC,OAAO,KAAK,CAAA,CAAA;AAAA,GAC/C,MAAA;AACL,IAAQ,KAAA,GAAA,+BAAA,CAAgC,OAAO,KAAK,CAAA,CAAA;AAAA,GACtD;AAEA,EAAO,OAAA,CAAA,EAAG,MAAO,CAAA,GAAA,CAAA,EAAM,QAAY,CAAA,CAAA,EAAA,KAAA,CAAA,CAAA,CAAA,CAAA;AACrC,CAAA;AAMO,SAAS,gCAAgC,UAA4B,EAAA;AAC1E,EAAO,OAAA,UAAA,CAAW,OAAQ,CAAA,KAAA,EAAO,MAAM,CAAA,CAAE,OAAQ,CAAA,KAAA,EAAO,KAAK,CAAA,CAAE,OAAQ,CAAA,IAAA,EAAM,KAAK,CAAA,CAAA;AACpF,CAAA;AAEO,SAAS,gCAAgC,UAA4B,EAAA;AAC1E,EAAO,OAAA,+BAAA,CAAgC,gBAAiB,CAAA,UAAU,CAAC,CAAA,CAAA;AACrE,CAAA;AAaA,MAAM,kBAAqB,GAAA,sBAAA,CAAA;AAC3B,SAAS,iBAAiB,KAAuB,EAAA;AAC/C,EAAO,OAAA,KAAA,CAAM,OAAQ,CAAA,kBAAA,EAAoB,MAAM,CAAA,CAAA;AACjD,CAAA;AAKO,SAAS,uBACd,YACA,EAAA;AACA,EAAA,MAAM,UAAU,UAAW,CAAA,cAAA;AAAA,IACzB,aAAa,OAAQ,EAAA;AAAA,IACrB,CAAC,MAAM,CAAa,YAAA,gBAAA;AAAA,GACtB,CAAA;AAEA,EAAA,MAAM,oBAAoB,iCAAkC,CAAA,OAAO,CAAE,CAAA,MAAA,CAAO,CAAC,CAAM,KAAA;AA5GrF,IAAA,IAAA,EAAA,EAAA,EAAA,CAAA;AA6GI,IAAO,OAAA,CAAA,CAAA,EAAA,GAAA,CAAA,CAAE,MAAM,UAAR,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAoB,WAAQ,EAAa,GAAA,YAAA,CAAA,KAAA,CAAM,eAAnB,IAA+B,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,GAAA,CAAA,CAAA;AAAA,GACnE,CAAA,CAAA;AAED,EAAI,IAAA,iBAAA,CAAkB,WAAW,CAAG,EAAA;AAClC,IAAA,OAAO,EAAC,CAAA;AAAA,GACV;AAEA,EAAA,MAAM,SAA2B,EAAC,CAAA;AAClC,EAAkB,iBAAA,CAAA,OAAA,CAAQ,CAAC,CAAM,KAAA;AAC/B,IAAA,MAAA,CAAO,IAAK,CAAA,GAAG,CAAE,CAAA,KAAA,CAAM,OAAO,CAAA,CAAA;AAAA,GAC/B,CAAA,CAAA;AAED,EAAO,OAAA,MAAA,CAAA;AACT,CAAA;AAKA,SAAS,kCAAkC,OAA6B,EAAA;AAEtE,EAAA,MAAM,eAAsD,EAAC,CAAA;AAE7D,EAAA,KAAA,MAAW,QAAQ,OAAS,EAAA;AAC1B,IAAI,IAAA,IAAA,CAAK,MAAM,GAAK,EAAA;AAClB,MAAA,IAAI,EAAE,IAAA,CAAK,KAAM,CAAA,GAAA,IAAO,YAAe,CAAA,EAAA;AACrC,QAAa,YAAA,CAAA,IAAA,CAAK,KAAM,CAAA,GAAA,CAAA,GAAO,EAAC,CAAA;AAAA,OAClC;AACA,MAAA,YAAA,CAAa,IAAK,CAAA,KAAA,CAAM,GAAK,CAAA,CAAA,IAAA,CAAK,IAAI,CAAA,CAAA;AAAA,KACxC;AAAA,GACF;AAGA,EAAA,OAAO,OAAO,MAAO,CAAA,YAAY,CAAE,CAAA,OAAA,CAAQ,CAAC,KAAU,KAAA;AACpD,IAAA,MAAM,cAAc,KAAM,CAAA,MAAA,CAAO,CAAC,IAAA,KAAS,KAAK,QAAQ,CAAA,CAAA;AAExD,IAAA,IAAI,WAAY,CAAA,MAAA,KAAW,CAAK,IAAA,KAAA,CAAM,WAAW,CAAG,EAAA;AAClD,MAAO,OAAA,KAAA,CAAA;AAAA,KACT;AACA,IAAO,OAAA,WAAA,CAAA;AAAA,GACR,CAAA,CAAA;AACH,CAAA;AAEO,SAAS,wBAAwB,KAAmC,EAAA;AACzE,EAAI,IAAA,KAAA,KAAU,IAAQ,IAAA,KAAA,KAAU,KAAW,CAAA,EAAA;AACzC,IAAO,OAAA,EAAA,CAAA;AAAA,GACT;AAGA,EAAA,OAAQ,KAAQ,GAAA,KAAA,CAAM,MAAO,CAAA,OAAA,CAAA,CAAS,OAAO,SAAS,CAAA,CAAA;AACxD,CAAA;AAEO,SAAS,yBAAyB,KAAmC,EAAA;AAC1E,EAAI,IAAA,KAAA,KAAU,IAAQ,IAAA,KAAA,KAAU,KAAW,CAAA,EAAA;AACzC,IAAO,OAAA,EAAA,CAAA;AAAA,GACT;AAGA,EAAA,OAAO,IAAK,CAAA,MAAA,CAAO,OAAS,CAAA,CAAA,KAAA,EAAO,SAAS,CAAA,CAAA;AAC9C,CAAA;AAEO,SAAS,sBAAsB,KAAmC,EAAA;AACvE,EAAI,IAAA,KAAA,KAAU,IAAQ,IAAA,KAAA,KAAU,KAAW,CAAA,EAAA;AACzC,IAAO,OAAA,EAAA,CAAA;AAAA,GACT;AAEA,EAAA,KAAA,GAAQ,UAAW,CAAA,MAAA,CAAO,OAAS,CAAA,CAAA,KAAA,EAAO,GAAG,CAAA,CAAA;AAC7C,EAAA,KAAA,GAAQ,UAAW,CAAA,MAAA,CAAO,OAAS,CAAA,CAAA,KAAA,EAAO,GAAG,CAAA,CAAA;AAE7C,EAAO,OAAA,KAAA,CAAA;AACT,CAAA;AAEgB,SAAA,yBAAA,CAA0B,KAAa,KAAwB,EAAA;AAE7E,EAAI,IAAA,CAAC,KAAS,IAAA,GAAA,KAAQ,KAAO,EAAA;AAC3B,IAAA,OAAO,yBAAyB,GAAG,CAAA,CAAA;AAAA,GACrC;AAEA,EAAO,OAAA,CAAC,KAAK,KAAK,CAAA,CAAE,IAAI,wBAAwB,CAAA,CAAE,KAAK,GAAG,CAAA,CAAA;AAC5D,CAAA;AAEO,SAAS,iBAAiB,QAA8C,EAAA;AAC7E,EAAA,OAAO,KAAM,CAAA,OAAA,CAAQ,QAAQ,CAAA,GAAI,WAAW,QAAS,CAAA,IAAA,CAAA;AACvD,CAAA;AAEO,SAAS,iBACd,QACwD,EAAA;AACxD,EAAA,OAAO,CAAC,KAAM,CAAA,OAAA,CAAQ,QAAQ,CAAK,IAAA,OAAA,CAAQ,SAAS,KAAK,CAAA,CAAA;AAC3D,CAAA;AAGO,SAAS,mBAAmB,MAA2D,EAAA;AAC5F,EAAA,MAAM,SAAyC,EAAC,CAAA;AAChD,EAAM,MAAA,cAAA,uBAAqB,GAA4C,EAAA,CAAA;AAEvE,EAAA,KAAA,MAAW,SAAS,MAAQ,EAAA;AAC1B,IAAA,MAAM,aAAa,KAAM,CAAA,KAAA,CAAA;AACzB,IAAA,IAAI,UAAY,EAAA;AACd,MAAI,IAAA,KAAA,GAAQ,cAAe,CAAA,GAAA,CAAI,UAAU,CAAA,CAAA;AAEzC,MAAA,IAAI,CAAC,KAAO,EAAA;AACV,QAAA,KAAA,GAAQ,EAAC,CAAA;AACT,QAAe,cAAA,CAAA,GAAA,CAAI,YAAY,KAAK,CAAA,CAAA;AACpC,QAAA,MAAA,CAAO,KAAK,EAAE,KAAA,EAAO,UAAY,EAAA,OAAA,EAAS,OAAO,CAAA,CAAA;AAAA,OACnD;AAEA,MAAA,KAAA,CAAM,KAAK,KAAK,CAAA,CAAA;AAAA,KACX,MAAA;AACL,MAAA,MAAA,CAAO,KAAK,KAAK,CAAA,CAAA;AAAA,KACnB;AAAA,GACF;AAEA,EAAO,OAAA,MAAA,CAAA;AACT,CAAA;AAEgB,SAAA,gBAAA,CAAiB,QAAoB,EAAA,KAAA,GAAQ,GAAQ,EAAA;AACnE,EAAM,MAAA,MAAA,GAAS,IAAI,MAAO,EAAA,CAAA;AAE1B,EAAA,MAAM,KAAQ,GAAA,KAAA,CAAM,IAAK,CAAA,EAAE,QAAQ,IAAK,CAAA,GAAA,CAAI,KAAO,EAAA,QAAA,CAAS,MAAM,CAAE,EAAA,EAAG,CAAC,CAAA,EAAG,MAAM,CAAC,CAAA,CAAA;AAGlF,EAAA,OAAO,CAAC,MAA6B,KAAA;AACnC,IAAA,IAAI,WAAW,EAAI,EAAA;AACjB,MAAO,OAAA,KAAA,CAAA;AAAA,KACT;AAEA,IAAM,MAAA,CAAC,MAAM,IAAM,EAAA,KAAK,IAAI,MAAO,CAAA,MAAA,CAAO,UAAU,MAAM,CAAA,CAAA;AAE1D,IAAA,IAAI,IAAM,EAAA;AACR,MAAA,IAAI,QAAQ,KAAO,EAAA;AACjB,QAAA,MAAM,UAAU,KAAM,CAAA,IAAA,CAAK,IAAI,KAAM,CAAA,MAAA,EAAQ,KAAK,CAAC,CAAA,CAAA;AAEnD,QAAA,KAAA,IAAS,CAAI,GAAA,CAAA,EAAG,CAAI,GAAA,OAAA,CAAQ,QAAQ,CAAK,EAAA,EAAA;AACvC,UAAQ,OAAA,CAAA,CAAA,CAAA,GAAK,IAAK,CAAA,GAAA,CAAI,KAAM,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,SAC9B;AAEA,QAAO,OAAA,OAAA,CAAA;AAAA,OACT;AAEA,MAAO,OAAA,IAAA,CAAK,KAAM,CAAA,CAAA,EAAG,KAAK,CAAA,CAAA;AAAA,KAC5B;AAEA,IAAA,OAAO,EAAC,CAAA;AAAA,GACV,CAAA;AACF;;;;"}

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

@@ -0,0 +1,38 @@
+import { SceneObjectBase } from '../../core/SceneObjectBase.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 ConstantVariable extends SceneObjectBase {
+  constructor(initialState) {
+    super(__spreadProps(__spreadValues({
+      type: "constant",
+      value: "",
+      name: ""
+    }, initialState), {
+      skipUrlSync: true
+    }));
+  }
+  getValue() {
+    return this.state.value;
+  }
+}
+
+export { ConstantVariable };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29uc3RhbnRWYXJpYWJsZS5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL3ZhcmlhYmxlcy92YXJpYW50cy9Db25zdGFudFZhcmlhYmxlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNjZW5lT2JqZWN0QmFzZSB9IGZyb20gJy4uLy4uL2NvcmUvU2NlbmVPYmplY3RCYXNlJztcbmltcG9ydCB7IFNjZW5lVmFyaWFibGUsIFNjZW5lVmFyaWFibGVTdGF0ZSwgVmFyaWFibGVWYWx1ZSB9IGZyb20gJy4uL3R5cGVzJztcblxuZXhwb3J0IGludGVyZmFjZSBDb25zdGFudFZhcmlhYmxlU3RhdGUgZXh0ZW5kcyBTY2VuZVZhcmlhYmxlU3RhdGUge1xuICB2YWx1ZTogVmFyaWFibGVWYWx1ZTtcbn1cblxuZXhwb3J0IGNsYXNzIENvbnN0YW50VmFyaWFibGVcbiAgZXh0ZW5kcyBTY2VuZU9iamVjdEJhc2U8Q29uc3RhbnRWYXJpYWJsZVN0YXRlPlxuICBpbXBsZW1lbnRzIFNjZW5lVmFyaWFibGU8Q29uc3RhbnRWYXJpYWJsZVN0YXRlPlxue1xuICBwdWJsaWMgY29uc3RydWN0b3IoaW5pdGlhbFN0YXRlOiBQYXJ0aWFsPENvbnN0YW50VmFyaWFibGVTdGF0ZT4pIHtcbiAgICBzdXBlcih7XG4gICAgICB0eXBlOiAnY29uc3RhbnQnLFxuICAgICAgdmFsdWU6ICcnLFxuICAgICAgbmFtZTogJycsXG4gICAgICAuLi5pbml0aWFsU3RhdGUsXG4gICAgICBza2lwVXJsU3luYzogdHJ1ZSxcbiAgICB9KTtcbiAgfVxuXG4gIHB1YmxpYyBnZXRWYWx1ZSgpOiBWYXJpYWJsZVZhbHVlIHtcbiAgICByZXR1cm4gdGhpcy5zdGF0ZS52YWx1ZTtcbiAgfVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQU9PLE1BQU0seUJBQ0gsZUFFVixDQUFBO0FBQUEsRUFDUyxZQUFZLFlBQThDLEVBQUE7QUFDL0QsSUFBTSxLQUFBLENBQUEsYUFBQSxDQUFBLGNBQUEsQ0FBQTtBQUFBLE1BQ0osSUFBTSxFQUFBLFVBQUE7QUFBQSxNQUNOLEtBQU8sRUFBQSxFQUFBO0FBQUEsTUFDUCxJQUFNLEVBQUEsRUFBQTtBQUFBLEtBQUEsRUFDSCxZQUpDLENBQUEsRUFBQTtBQUFBLE1BS0osV0FBYSxFQUFBLElBQUE7QUFBQSxLQUNkLENBQUEsQ0FBQSxDQUFBO0FBQUEsR0FDSDtBQUFBLEVBRU8sUUFBMEIsR0FBQTtBQUMvQixJQUFBLE9BQU8sS0FBSyxLQUFNLENBQUEsS0FBQSxDQUFBO0FBQUEsR0FDcEI7QUFDRjs7OzsifQ==