@grafana/scenes 6.7.0 → 6.8.0

package/dist/esm/src/querying/layers/SceneDataLayerBase.js

@@ -0,0 +1,112 @@
+import { ReplaySubject } from 'rxjs';
+import { emptyPanelData } from '../../core/SceneDataNode.js';
+import { SceneObjectBase } from '../../core/SceneObjectBase.js';
+import { setBaseClassState } from '../../utils/utils.js';
+import { writeSceneLog } from '../../utils/writeSceneLog.js';
+import { VariableDependencyConfig } from '../../variables/VariableDependencyConfig.js';
+import { VariableValueRecorder } from '../../variables/VariableValueRecorder.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 SceneDataLayerBase extends SceneObjectBase {
+  constructor(initialState, variableDependencyStatePaths = []) {
+    super(__spreadValues({
+      isEnabled: true
+    }, initialState));
+    this._results = new ReplaySubject(1);
+    this.isDataLayer = true;
+    this._variableValueRecorder = new VariableValueRecorder();
+    this._variableDependency = new VariableDependencyConfig(this, {
+      onVariableUpdateCompleted: this.onVariableUpdateCompleted.bind(this)
+    });
+    this._variableDependency.setPaths(variableDependencyStatePaths);
+    this.addActivationHandler(() => this.onActivate());
+  }
+  onActivate() {
+    if (this.state.isEnabled) {
+      this.onEnable();
+    }
+    if (this.shouldRunLayerOnActivate()) {
+      this.runLayer();
+    }
+    this.subscribeToState((n, p) => {
+      if (!n.isEnabled && this.querySub) {
+        this.querySub.unsubscribe();
+        this.querySub = void 0;
+        this.onDisable();
+        this._results.next({ origin: this, data: emptyPanelData });
+        this.setStateHelper({ data: emptyPanelData });
+      }
+      if (n.isEnabled && !p.isEnabled) {
+        this.onEnable();
+        this.runLayer();
+      }
+    });
+    return () => {
+      this.onDeactivate();
+    };
+  }
+  onDeactivate() {
+    if (this.querySub) {
+      this.querySub.unsubscribe();
+      this.querySub = void 0;
+    }
+    this.onDisable();
+    this._variableValueRecorder.recordCurrentDependencyValuesForSceneObject(this);
+  }
+  onVariableUpdateCompleted() {
+    this.runLayer();
+  }
+  cancelQuery() {
+    if (this.querySub) {
+      this.querySub.unsubscribe();
+      this.querySub = void 0;
+      this.publishResults(emptyPanelData);
+    }
+  }
+  publishResults(data) {
+    if (this.state.isEnabled) {
+      this._results.next({ origin: this, data });
+      this.setStateHelper({ data });
+    }
+  }
+  getResultsStream() {
+    return this._results;
+  }
+  shouldRunLayerOnActivate() {
+    if (!this.state.isEnabled) {
+      return false;
+    }
+    if (this._variableValueRecorder.hasDependenciesChanged(this)) {
+      writeSceneLog(
+        "SceneDataLayerBase",
+        "Variable dependency changed while inactive, shouldRunLayerOnActivate returns true"
+      );
+      return true;
+    }
+    if (!this.state.data) {
+      return true;
+    }
+    return false;
+  }
+  setStateHelper(state) {
+    setBaseClassState(this, state);
+  }
+}
+
+export { SceneDataLayerBase };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"SceneDataLayerBase.js","sources":["../../../../../src/querying/layers/SceneDataLayerBase.ts"],"sourcesContent":["import { PanelData } from '@grafana/data';\nimport { ReplaySubject, Unsubscribable } from 'rxjs';\nimport { emptyPanelData } from '../../core/SceneDataNode';\nimport { SceneObjectBase } from '../../core/SceneObjectBase';\nimport {\n  CancelActivationHandler,\n  SceneDataLayerProvider,\n  SceneDataProviderResult,\n  SceneDataLayerProviderState,\n} from '../../core/types';\nimport { setBaseClassState } from '../../utils/utils';\nimport { writeSceneLog } from '../../utils/writeSceneLog';\nimport { VariableDependencyConfig } from '../../variables/VariableDependencyConfig';\nimport { VariableValueRecorder } from '../../variables/VariableValueRecorder';\n\n/**\n * Base class for data layer. Handles common implementation including enabling/disabling layer and publishing results.\n */\nexport abstract class SceneDataLayerBase<T extends SceneDataLayerProviderState>\n  extends SceneObjectBase<T>\n  implements SceneDataLayerProvider\n{\n  /**\n   * Subscription to query results. Should be set when layer runs a query.\n   */\n  protected querySub?: Unsubscribable;\n\n  /**\n   * Subject to emit results to.\n   */\n  private _results = new ReplaySubject<SceneDataProviderResult>(1);\n\n  /**\n   * Implement logic for enabling the layer. This is called when layer is enabled or when layer is enabled when activated.\n   * Use i.e. to setup subscriptions that will trigger layer updates.\n   */\n  public abstract onEnable(): void;\n\n  /**\n   * Implement logic for disabling the layer. This is called when layer is disabled.\n   * Use i.e. to unsubscribe from subscriptions that trigger layer updates.\n   */\n  public abstract onDisable(): void;\n\n  /**\n   * Implement logic running the layer and setting up the querySub subscription.\n   */\n  protected abstract runLayer(): void;\n\n  /**\n   * Mark data provider as data layer\n   */\n  public isDataLayer: true = true;\n\n  private _variableValueRecorder = new VariableValueRecorder();\n\n  protected _variableDependency: VariableDependencyConfig<T> = new VariableDependencyConfig(this, {\n    onVariableUpdateCompleted: this.onVariableUpdateCompleted.bind(this),\n  });\n\n  /**\n   * For variables support in data layer provide variableDependencyStatePaths with keys of the state to be scanned for variables.\n   */\n  public constructor(initialState: T, variableDependencyStatePaths: Array<keyof T> = []) {\n    super({\n      isEnabled: true,\n      ...initialState,\n    });\n\n    this._variableDependency.setPaths(variableDependencyStatePaths);\n    this.addActivationHandler(() => this.onActivate());\n  }\n\n  protected onActivate(): CancelActivationHandler {\n    if (this.state.isEnabled) {\n      this.onEnable();\n    }\n\n    if (this.shouldRunLayerOnActivate()) {\n      this.runLayer();\n    }\n\n    // Subscribe to layer state changes and enable/disable layer accordingly.\n    this.subscribeToState((n, p) => {\n      if (!n.isEnabled && this.querySub) {\n        // When layer disabled, cancel query and call onDisable that should publish empty results.\n        this.querySub.unsubscribe();\n        this.querySub = undefined;\n        this.onDisable();\n\n        // Manually publishing the results to state and results stream as publishPublish results has a guard for the layer to be enabled.\n        this._results.next({ origin: this, data: emptyPanelData });\n\n        this.setStateHelper({ data: emptyPanelData });\n      }\n\n      if (n.isEnabled && !p.isEnabled) {\n        // When layer enabled, run queries.\n        this.onEnable();\n        this.runLayer();\n      }\n    });\n\n    return () => {\n      this.onDeactivate();\n    };\n  }\n\n  protected onDeactivate(): void {\n    if (this.querySub) {\n      this.querySub.unsubscribe();\n      this.querySub = undefined;\n    }\n\n    this.onDisable();\n\n    this._variableValueRecorder.recordCurrentDependencyValuesForSceneObject(this);\n  }\n\n  protected onVariableUpdateCompleted(): void {\n    this.runLayer();\n  }\n\n  public cancelQuery() {\n    if (this.querySub) {\n      this.querySub.unsubscribe();\n      this.querySub = undefined;\n\n      this.publishResults(emptyPanelData);\n    }\n  }\n\n  protected publishResults(data: PanelData) {\n    if (this.state.isEnabled) {\n      this._results.next({ origin: this, data });\n      this.setStateHelper({ data });\n    }\n  }\n\n  public getResultsStream() {\n    return this._results;\n  }\n\n  private shouldRunLayerOnActivate() {\n    if (!this.state.isEnabled) {\n      return false;\n    }\n\n    if (this._variableValueRecorder.hasDependenciesChanged(this)) {\n      writeSceneLog(\n        'SceneDataLayerBase',\n        'Variable dependency changed while inactive, shouldRunLayerOnActivate returns true'\n      );\n      return true;\n    }\n\n    if (!this.state.data) {\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * This helper function is to counter the contravariance of setState\n   */\n  private setStateHelper(state: Partial<SceneDataLayerProviderState>) {\n    setBaseClassState<SceneDataLayerProviderState>(this, state);\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/src/querying/layers/SceneDataLayerControls.js

@@ -0,0 +1,51 @@
+import { css } from '@emotion/css';
+import { LoadingState } from '@grafana/schema';
+import { InlineSwitch } from '@grafana/ui';
+import React from 'react';
+import { sceneGraph } from '../../core/sceneGraph/index.js';
+import { SceneObjectBase } from '../../core/SceneObjectBase.js';
+import { ControlsLabel } from '../../utils/ControlsLabel.js';
+
+class SceneDataLayerControls extends SceneObjectBase {
+  constructor() {
+    super({});
+  }
+}
+SceneDataLayerControls.Component = SceneDataLayerControlsRenderer;
+function SceneDataLayerControlsRenderer({ model }) {
+  const layers = sceneGraph.getDataLayers(model, true);
+  if (layers.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, layers.map((layer) => /* @__PURE__ */ React.createElement(layer.Component, {
+    model: layer,
+    key: layer.state.key
+  })));
+}
+function DataLayerControlSwitch({ layer }) {
+  var _a, _b;
+  const elementId = `data-layer-${layer.state.key}`;
+  const { data, isEnabled } = layer.useState();
+  const showLoading = Boolean(data && data.state === LoadingState.Loading);
+  return /* @__PURE__ */ React.createElement("div", {
+    className: containerStyle
+  }, /* @__PURE__ */ React.createElement(ControlsLabel, {
+    htmlFor: elementId,
+    isLoading: showLoading,
+    onCancel: () => {
+      var _a2;
+      return (_a2 = layer.cancelQuery) == null ? void 0 : _a2.call(layer);
+    },
+    label: layer.state.name,
+    description: layer.state.description,
+    error: (_b = (_a = layer.state.data) == null ? void 0 : _a.errors) == null ? void 0 : _b[0].message
+  }), /* @__PURE__ */ React.createElement(InlineSwitch, {
+    id: elementId,
+    value: isEnabled,
+    onChange: () => layer.setState({ isEnabled: !isEnabled })
+  }));
+}
+const containerStyle = css({ display: "flex" });
+
+export { DataLayerControlSwitch, SceneDataLayerControls };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/querying/layers/annotations/AnnotationsDataLayer.js

@@ -0,0 +1,130 @@
+import { arrayToDataFrame, DataTopic } from '@grafana/data';
+import { LoadingState } from '@grafana/schema';
+import React from 'react';
+import { map } from 'rxjs';
+import { emptyPanelData } from '../../../core/SceneDataNode.js';
+import { sceneGraph } from '../../../core/sceneGraph/index.js';
+import { getDataSource } from '../../../utils/getDataSource.js';
+import { getMessageFromError } from '../../../utils/getMessageFromError.js';
+import { writeSceneLog } from '../../../utils/writeSceneLog.js';
+import { registerQueryWithController } from '../../registerQueryWithController.js';
+import { SceneDataLayerBase } from '../SceneDataLayerBase.js';
+import { DataLayerControlSwitch } from '../SceneDataLayerControls.js';
+import { executeAnnotationQuery } from './standardAnnotationQuery.js';
+import { postProcessQueryResult, dedupAnnotations } from './utils.js';
+import { wrapInSafeSerializableSceneObject } from '../../../utils/wrapInSafeSerializableSceneObject.js';
+import { RefreshEvent } from '@grafana/runtime';
+
+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 AnnotationsDataLayer extends SceneDataLayerBase {
+  constructor(initialState) {
+    super(
+      __spreadValues({
+        isEnabled: true
+      }, initialState),
+      ["query"]
+    );
+    this._scopedVars = {
+      __sceneObject: wrapInSafeSerializableSceneObject(this)
+    };
+  }
+  onEnable() {
+    this.publishEvent(new RefreshEvent(), true);
+    const timeRange = sceneGraph.getTimeRange(this);
+    this._timeRangeSub = timeRange.subscribeToState(() => {
+      this.runWithTimeRange(timeRange);
+    });
+  }
+  onDisable() {
+    var _a;
+    this.publishEvent(new RefreshEvent(), true);
+    (_a = this._timeRangeSub) == null ? void 0 : _a.unsubscribe();
+  }
+  runLayer() {
+    writeSceneLog("AnnotationsDataLayer", "run layer");
+    const timeRange = sceneGraph.getTimeRange(this);
+    this.runWithTimeRange(timeRange);
+  }
+  async runWithTimeRange(timeRange) {
+    const { query } = this.state;
+    if (this.querySub) {
+      this.querySub.unsubscribe();
+    }
+    if (this._variableDependency.hasDependencyInLoadingState()) {
+      writeSceneLog("AnnotationsDataLayer", "Variable dependency is in loading state, skipping query execution");
+      return;
+    }
+    try {
+      const ds = await this.resolveDataSource(query);
+      let stream = executeAnnotationQuery(ds, timeRange, query, this).pipe(
+        registerQueryWithController({
+          type: "annotations",
+          origin: this,
+          cancel: () => this.cancelQuery()
+        }),
+        map((events) => {
+          const stateUpdate = this.processEvents(query, events);
+          return stateUpdate;
+        })
+      );
+      this.querySub = stream.subscribe((stateUpdate) => {
+        this.publishResults(stateUpdate);
+      });
+    } catch (e) {
+      this.publishResults(__spreadProps(__spreadValues({}, emptyPanelData), {
+        state: LoadingState.Error,
+        errors: [
+          {
+            message: getMessageFromError(e)
+          }
+        ]
+      }));
+      console.error("AnnotationsDataLayer error", e);
+    }
+  }
+  async resolveDataSource(query) {
+    return await getDataSource(query.datasource || void 0, this._scopedVars);
+  }
+  processEvents(query, events) {
+    let processedEvents = postProcessQueryResult(query, events.events || []);
+    processedEvents = dedupAnnotations(processedEvents);
+    const stateUpdate = __spreadProps(__spreadValues({}, emptyPanelData), { state: events.state });
+    const df = arrayToDataFrame(processedEvents);
+    df.meta = __spreadProps(__spreadValues({}, df.meta), {
+      dataTopic: DataTopic.Annotations
+    });
+    stateUpdate.series = [df];
+    return stateUpdate;
+  }
+}
+AnnotationsDataLayer.Component = AnnotationsDataLayerRenderer;
+function AnnotationsDataLayerRenderer({ model }) {
+  const { isHidden } = model.useState();
+  if (isHidden) {
+    return null;
+  }
+  return /* @__PURE__ */ React.createElement(DataLayerControlSwitch, {
+    layer: model
+  });
+}
+
+export { AnnotationsDataLayer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"AnnotationsDataLayer.js","sources":["../../../../../../src/querying/layers/annotations/AnnotationsDataLayer.tsx"],"sourcesContent":["import { arrayToDataFrame, DataTopic, AnnotationQuery, ScopedVars, PanelData } from '@grafana/data';\nimport { LoadingState } from '@grafana/schema';\nimport React from 'react';\nimport { map, Unsubscribable } from 'rxjs';\nimport { emptyPanelData } from '../../../core/SceneDataNode';\nimport { sceneGraph } from '../../../core/sceneGraph';\nimport {\n  SceneComponentProps,\n  SceneDataLayerProvider,\n  SceneDataLayerProviderState,\n  SceneTimeRangeLike,\n} from '../../../core/types';\nimport { getDataSource } from '../../../utils/getDataSource';\nimport { getMessageFromError } from '../../../utils/getMessageFromError';\nimport { writeSceneLog } from '../../../utils/writeSceneLog';\nimport { registerQueryWithController } from '../../registerQueryWithController';\nimport { SceneDataLayerBase } from '../SceneDataLayerBase';\nimport { DataLayerControlSwitch } from '../SceneDataLayerControls';\nimport { AnnotationQueryResults, executeAnnotationQuery } from './standardAnnotationQuery';\nimport { dedupAnnotations, postProcessQueryResult } from './utils';\nimport { wrapInSafeSerializableSceneObject } from '../../../utils/wrapInSafeSerializableSceneObject';\nimport { RefreshEvent } from '@grafana/runtime';\n\ninterface AnnotationsDataLayerState extends SceneDataLayerProviderState {\n  query: AnnotationQuery;\n}\n\nexport class AnnotationsDataLayer\n  extends SceneDataLayerBase<AnnotationsDataLayerState>\n  implements SceneDataLayerProvider\n{\n  static Component = AnnotationsDataLayerRenderer;\n\n  private _scopedVars: ScopedVars = {\n    __sceneObject: wrapInSafeSerializableSceneObject(this),\n  };\n  private _timeRangeSub: Unsubscribable | undefined;\n\n  public constructor(initialState: AnnotationsDataLayerState) {\n    super(\n      {\n        isEnabled: true,\n        ...initialState,\n      },\n      ['query']\n    );\n  }\n\n  public onEnable(): void {\n    this.publishEvent(new RefreshEvent(), true);\n\n    const timeRange = sceneGraph.getTimeRange(this);\n\n    this._timeRangeSub = timeRange.subscribeToState(() => {\n      this.runWithTimeRange(timeRange);\n    });\n  }\n\n  public onDisable(): void {\n    this.publishEvent(new RefreshEvent(), true);\n\n    this._timeRangeSub?.unsubscribe();\n  }\n\n  public runLayer() {\n    writeSceneLog('AnnotationsDataLayer', 'run layer');\n    const timeRange = sceneGraph.getTimeRange(this);\n    this.runWithTimeRange(timeRange);\n  }\n\n  private async runWithTimeRange(timeRange: SceneTimeRangeLike) {\n    const { query } = this.state;\n\n    if (this.querySub) {\n      this.querySub.unsubscribe();\n    }\n\n    if (this._variableDependency.hasDependencyInLoadingState()) {\n      writeSceneLog('AnnotationsDataLayer', 'Variable dependency is in loading state, skipping query execution');\n      return;\n    }\n\n    try {\n      const ds = await this.resolveDataSource(query);\n\n      let stream = executeAnnotationQuery(ds, timeRange, query, this).pipe(\n        registerQueryWithController({\n          type: 'annotations',\n          origin: this,\n          cancel: () => this.cancelQuery(),\n        }),\n        map((events) => {\n          const stateUpdate = this.processEvents(query, events);\n          return stateUpdate;\n        })\n      );\n\n      this.querySub = stream.subscribe((stateUpdate) => {\n        this.publishResults(stateUpdate);\n      });\n    } catch (e) {\n      this.publishResults({\n        ...emptyPanelData,\n        state: LoadingState.Error,\n        errors: [\n          {\n            message: getMessageFromError(e),\n          },\n        ],\n      });\n      console.error('AnnotationsDataLayer error', e);\n    }\n  }\n\n  protected async resolveDataSource(query: AnnotationQuery) {\n    return await getDataSource(query.datasource || undefined, this._scopedVars);\n  }\n\n  protected processEvents(query: AnnotationQuery, events: AnnotationQueryResults): PanelData {\n    let processedEvents = postProcessQueryResult(query, events.events || []);\n    processedEvents = dedupAnnotations(processedEvents);\n\n    const stateUpdate = { ...emptyPanelData, state: events.state };\n    const df = arrayToDataFrame(processedEvents);\n\n    df.meta = {\n      ...df.meta,\n      dataTopic: DataTopic.Annotations,\n    };\n\n    stateUpdate.series = [df];\n\n    return stateUpdate;\n  }\n}\n\nfunction AnnotationsDataLayerRenderer({ model }: SceneComponentProps<AnnotationsDataLayer>) {\n  const { isHidden } = model.useState();\n\n  if (isHidden) {\n    return null;\n  }\n\n  return <DataLayerControlSwitch layer={model} />;\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/src/querying/layers/annotations/filterAnnotations.js

@@ -0,0 +1,85 @@
+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));
+const GLOBAL_ANNOTATION_ID = 0;
+function filterAnnotations(data, filters) {
+  var _a;
+  if (!Array.isArray(data) || data.length === 0) {
+    return data;
+  }
+  const rows = Array.from({ length: data.length }, () => /* @__PURE__ */ new Set());
+  let frameIdx = 0;
+  for (const frame of data) {
+    for (let index = 0; index < frame.length; index++) {
+      if (rows[frameIdx].has(index)) {
+        continue;
+      }
+      let matching = true;
+      const panelIdField = frame.fields.find((f) => f.name === "panelId");
+      const sourceField = frame.fields.find((f) => f.name === "source");
+      if (sourceField) {
+        if (panelIdField && sourceField.values[index].type === "dashboard") {
+          matching = [filters.panelId, GLOBAL_ANNOTATION_ID].includes(panelIdField.values[index]);
+        }
+        const sourceFilter = sourceField.values[index].filter;
+        if (sourceFilter) {
+          const includes = [...(_a = sourceFilter.ids) != null ? _a : [], GLOBAL_ANNOTATION_ID].includes(filters.panelId);
+          if (sourceFilter.exclude) {
+            if (includes) {
+              matching = false;
+            }
+          } else if (!includes) {
+            matching = false;
+          }
+        }
+      }
+      if (matching) {
+        rows[frameIdx].add(index);
+      }
+    }
+    frameIdx++;
+  }
+  const processed = [];
+  frameIdx = 0;
+  for (const frame of data) {
+    const frameLength = rows[frameIdx].size;
+    const fields = [];
+    for (const field of frame.fields) {
+      const buffer = [];
+      for (let index = 0; index < frame.length; index++) {
+        if (rows[frameIdx].has(index)) {
+          buffer.push(field.values[index]);
+          continue;
+        }
+      }
+      fields.push(__spreadProps(__spreadValues({}, field), {
+        values: buffer
+      }));
+    }
+    processed.push(__spreadProps(__spreadValues({}, frame), {
+      fields,
+      length: frameLength
+    }));
+    frameIdx++;
+  }
+  return processed;
+}
+
+export { filterAnnotations };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyQW5ub3RhdGlvbnMuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9xdWVyeWluZy9sYXllcnMvYW5ub3RhdGlvbnMvZmlsdGVyQW5ub3RhdGlvbnMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGF0YUZyYW1lLCBGaWVsZCB9IGZyb20gJ0BncmFmYW5hL2RhdGEnO1xuaW1wb3J0IHsgRGF0YUxheWVyRmlsdGVyIH0gZnJvbSAnLi4vLi4vLi4vY29yZS90eXBlcyc7XG5cbmNvbnN0IEdMT0JBTF9BTk5PVEFUSU9OX0lEID0gMDtcblxuLy8gUHJvdmlkZWQgU2NlbmVEYXRhTGF5ZXJQcm92aWRlclJlc3VsdCBpcyBhbiBhcnJheSBvZiBEYXRhRnJhbWVzLlxuZXhwb3J0IGZ1bmN0aW9uIGZpbHRlckFubm90YXRpb25zKGRhdGE6IERhdGFGcmFtZVtdLCBmaWx0ZXJzOiBEYXRhTGF5ZXJGaWx0ZXIpIHtcbiAgaWYgKCFBcnJheS5pc0FycmF5KGRhdGEpIHx8IGRhdGEubGVuZ3RoID09PSAwKSB7XG4gICAgcmV0dXJuIGRhdGE7XG4gIH1cblxuICBjb25zdCByb3dzID0gQXJyYXkuZnJvbSh7IGxlbmd0aDogZGF0YS5sZW5ndGggfSwgKCkgPT4gbmV3IFNldDxudW1iZXI+KCkpO1xuXG4gIGxldCBmcmFtZUlkeCA9IDA7XG4gIGZvciAoY29uc3QgZnJhbWUgb2YgZGF0YSkge1xuICAgIGZvciAobGV0IGluZGV4ID0gMDsgaW5kZXggPCBmcmFtZS5sZW5ndGg7IGluZGV4KyspIHtcbiAgICAgIGlmIChyb3dzW2ZyYW1lSWR4XS5oYXMoaW5kZXgpKSB7XG4gICAgICAgIGNvbnRpbnVlO1xuICAgICAgfVxuICAgICAgbGV0IG1hdGNoaW5nID0gdHJ1ZTtcblxuICAgICAgLy8gTGV0J3MgY2FsbCB0aG9zZSBzdGFuZGFyZCBmaWVsZHMgdGhhdCBhbm5vdGF0aW9ucyBkYXRhIGZyYW1lIGhhcy5cbiAgICAgIC8vIHBhbmVsSWQgaXMgYSBzdGFuZGFyZCBmaWVsZCwgYnV0IGl0J3Mgbm90IGFsd2F5cyBwcmVzZW50LiBJdCdzIGFkZGVkIHRvIGFubm90YXRpb25zIHRoYXQgd2VyZSBhZGRlZCB0byBhIHBhcnRpY3VsYXIgcGFuZWwuXG4gICAgICBjb25zdCBwYW5lbElkRmllbGQgPSBmcmFtZS5maWVsZHMuZmluZCgoZikgPT4gZi5uYW1lID09PSAncGFuZWxJZCcpO1xuICAgICAgLy8gU291cmNlIGZpZWxkIGNvbnRhaW5zIGFubm90YXRpb24gZGVmaW5pdGlvbiwgd2l0aCB0eXBlIGFuZCBmaWx0ZXJzIGluY2x1ZGVkLlxuICAgICAgY29uc3Qgc291cmNlRmllbGQgPSBmcmFtZS5maWVsZHMuZmluZCgoZikgPT4gZi5uYW1lID09PSAnc291cmNlJyk7XG5cbiAgICAgIGlmIChzb3VyY2VGaWVsZCkge1xuICAgICAgICAvLyBIZXJlIHdlIGFyZSBmaWx0ZXJpbmcgR3JhZmFuYSBhbm5vdGF0aW9ucyB0aGF0IHdlcmUgYWRkZWQgdG8gYSBwYXJ0aWN1bGFyIHBhbmVsLlxuICAgICAgICBpZiAocGFuZWxJZEZpZWxkICYmIHNvdXJjZUZpZWxkLnZhbHVlc1tpbmRleF0udHlwZSA9PT0gJ2Rhc2hib2FyZCcpIHtcbiAgICAgICAgICBtYXRjaGluZyA9IFtmaWx0ZXJzLnBhbmVsSWQsIEdMT0JBTF9BTk5PVEFUSU9OX0lEXS5pbmNsdWRlcyhwYW5lbElkRmllbGQudmFsdWVzW2luZGV4XSk7XG4gICAgICAgIH1cblxuICAgICAgICBjb25zdCBzb3VyY2VGaWx0ZXIgPSBzb3VyY2VGaWVsZC52YWx1ZXNbaW5kZXhdLmZpbHRlcjtcblxuICAgICAgICAvLyBIZXJlIHdlIGFyZSBmaWx0ZXJpbmcgYmFzZWQgb24gYW5ub3RhdGlvbiBmaWx0ZXIgZGVmaW5pdGlvbi5cbiAgICAgICAgLy8gVGhvc2UgZmlsdGVycyBhcmU6IFNob3cgYW5ub3RhdGlvbiBpbiBzZWxlY3RlZCBwYW5lbHMsIEV4Y2x1ZGUgYW5ub3RhdGlvbiBmcm9tIHNlbGVjdGVkIHBhbmVscy5cbiAgICAgICAgaWYgKHNvdXJjZUZpbHRlcikge1xuICAgICAgICAgIGNvbnN0IGluY2x1ZGVzID0gWy4uLihzb3VyY2VGaWx0ZXIuaWRzID8/IFtdKSwgR0xPQkFMX0FOTk9UQVRJT05fSURdLmluY2x1ZGVzKGZpbHRlcnMucGFuZWxJZCk7XG4gICAgICAgICAgaWYgKHNvdXJjZUZpbHRlci5leGNsdWRlKSB7XG4gICAgICAgICAgICBpZiAoaW5jbHVkZXMpIHtcbiAgICAgICAgICAgICAgbWF0Y2hpbmcgPSBmYWxzZTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICB9IGVsc2UgaWYgKCFpbmNsdWRlcykge1xuICAgICAgICAgICAgbWF0Y2hpbmcgPSBmYWxzZTtcbiAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgIH1cblxuICAgICAgaWYgKG1hdGNoaW5nKSB7XG4gICAgICAgIHJvd3NbZnJhbWVJZHhdLmFkZChpbmRleCk7XG4gICAgICB9XG4gICAgfVxuICAgIGZyYW1lSWR4Kys7XG4gIH1cblxuICBjb25zdCBwcm9jZXNzZWQ6IERhdGFGcmFtZVtdID0gW107XG5cbiAgZnJhbWVJZHggPSAwO1xuICBmb3IgKGNvbnN0IGZyYW1lIG9mIGRhdGEpIHtcbiAgICBjb25zdCBmcmFtZUxlbmd0aCA9IHJvd3NbZnJhbWVJZHhdLnNpemU7XG4gICAgY29uc3QgZmllbGRzOiBGaWVsZFtdID0gW107XG5cbiAgICBmb3IgKGNvbnN0IGZpZWxkIG9mIGZyYW1lLmZpZWxkcykge1xuICAgICAgY29uc3QgYnVmZmVyID0gW107XG5cbiAgICAgIGZvciAobGV0IGluZGV4ID0gMDsgaW5kZXggPCBmcmFtZS5sZW5ndGg7IGluZGV4KyspIHtcbiAgICAgICAgaWYgKHJvd3NbZnJhbWVJZHhdLmhhcyhpbmRleCkpIHtcbiAgICAgICAgICBidWZmZXIucHVzaChmaWVsZC52YWx1ZXNbaW5kZXhdKTtcbiAgICAgICAgICBjb250aW51ZTtcbiAgICAgICAgfVxuICAgICAgfVxuXG4gICAgICBmaWVsZHMucHVzaCh7XG4gICAgICAgIC4uLmZpZWxkLFxuICAgICAgICB2YWx1ZXM6IGJ1ZmZlcixcbiAgICAgIH0pO1xuICAgIH1cblxuICAgIHByb2Nlc3NlZC5wdXNoKHtcbiAgICAgIC4uLmZyYW1lLFxuICAgICAgZmllbGRzOiBmaWVsZHMsXG4gICAgICBsZW5ndGg6IGZyYW1lTGVuZ3RoLFxuICAgIH0pO1xuICAgIGZyYW1lSWR4Kys7XG4gIH1cblxuICByZXR1cm4gcHJvY2Vzc2VkO1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFHQSxNQUFNLG9CQUF1QixHQUFBLENBQUEsQ0FBQTtBQUdiLFNBQUEsaUJBQUEsQ0FBa0IsTUFBbUIsT0FBMEIsRUFBQTtBQU4vRSxFQUFBLElBQUEsRUFBQSxDQUFBO0FBT0UsRUFBQSxJQUFJLENBQUMsS0FBTSxDQUFBLE9BQUEsQ0FBUSxJQUFJLENBQUssSUFBQSxJQUFBLENBQUssV0FBVyxDQUFHLEVBQUE7QUFDN0MsSUFBTyxPQUFBLElBQUEsQ0FBQTtBQUFBLEdBQ1Q7QUFFQSxFQUFNLE1BQUEsSUFBQSxHQUFPLEtBQU0sQ0FBQSxJQUFBLENBQUssRUFBRSxNQUFBLEVBQVEsSUFBSyxDQUFBLE1BQUEsRUFBVSxFQUFBLHNCQUFVLElBQUEsR0FBQSxFQUFhLENBQUEsQ0FBQTtBQUV4RSxFQUFBLElBQUksUUFBVyxHQUFBLENBQUEsQ0FBQTtBQUNmLEVBQUEsS0FBQSxNQUFXLFNBQVMsSUFBTSxFQUFBO0FBQ3hCLElBQUEsS0FBQSxJQUFTLEtBQVEsR0FBQSxDQUFBLEVBQUcsS0FBUSxHQUFBLEtBQUEsQ0FBTSxRQUFRLEtBQVMsRUFBQSxFQUFBO0FBQ2pELE1BQUEsSUFBSSxJQUFLLENBQUEsUUFBQSxDQUFBLENBQVUsR0FBSSxDQUFBLEtBQUssQ0FBRyxFQUFBO0FBQzdCLFFBQUEsU0FBQTtBQUFBLE9BQ0Y7QUFDQSxNQUFBLElBQUksUUFBVyxHQUFBLElBQUEsQ0FBQTtBQUlmLE1BQU0sTUFBQSxZQUFBLEdBQWUsTUFBTSxNQUFPLENBQUEsSUFBQSxDQUFLLENBQUMsQ0FBTSxLQUFBLENBQUEsQ0FBRSxTQUFTLFNBQVMsQ0FBQSxDQUFBO0FBRWxFLE1BQU0sTUFBQSxXQUFBLEdBQWMsTUFBTSxNQUFPLENBQUEsSUFBQSxDQUFLLENBQUMsQ0FBTSxLQUFBLENBQUEsQ0FBRSxTQUFTLFFBQVEsQ0FBQSxDQUFBO0FBRWhFLE1BQUEsSUFBSSxXQUFhLEVBQUE7QUFFZixRQUFBLElBQUksWUFBZ0IsSUFBQSxXQUFBLENBQVksTUFBTyxDQUFBLEtBQUEsQ0FBQSxDQUFPLFNBQVMsV0FBYSxFQUFBO0FBQ2xFLFVBQVcsUUFBQSxHQUFBLENBQUMsUUFBUSxPQUFTLEVBQUEsb0JBQW9CLEVBQUUsUUFBUyxDQUFBLFlBQUEsQ0FBYSxPQUFPLEtBQU0sQ0FBQSxDQUFBLENBQUE7QUFBQSxTQUN4RjtBQUVBLFFBQU0sTUFBQSxZQUFBLEdBQWUsV0FBWSxDQUFBLE1BQUEsQ0FBTyxLQUFPLENBQUEsQ0FBQSxNQUFBLENBQUE7QUFJL0MsUUFBQSxJQUFJLFlBQWMsRUFBQTtBQUNoQixVQUFBLE1BQU0sUUFBVyxHQUFBLENBQUMsR0FBSSxDQUFBLEVBQUEsR0FBQSxZQUFBLENBQWEsR0FBYixLQUFBLElBQUEsR0FBQSxFQUFBLEdBQW9CLEVBQUMsRUFBSSxvQkFBb0IsQ0FBQSxDQUFFLFFBQVMsQ0FBQSxPQUFBLENBQVEsT0FBTyxDQUFBLENBQUE7QUFDN0YsVUFBQSxJQUFJLGFBQWEsT0FBUyxFQUFBO0FBQ3hCLFlBQUEsSUFBSSxRQUFVLEVBQUE7QUFDWixjQUFXLFFBQUEsR0FBQSxLQUFBLENBQUE7QUFBQSxhQUNiO0FBQUEsV0FDRixNQUFBLElBQVcsQ0FBQyxRQUFVLEVBQUE7QUFDcEIsWUFBVyxRQUFBLEdBQUEsS0FBQSxDQUFBO0FBQUEsV0FDYjtBQUFBLFNBQ0Y7QUFBQSxPQUNGO0FBRUEsTUFBQSxJQUFJLFFBQVUsRUFBQTtBQUNaLFFBQUssSUFBQSxDQUFBLFFBQUEsQ0FBQSxDQUFVLElBQUksS0FBSyxDQUFBLENBQUE7QUFBQSxPQUMxQjtBQUFBLEtBQ0Y7QUFDQSxJQUFBLFFBQUEsRUFBQSxDQUFBO0FBQUEsR0FDRjtBQUVBLEVBQUEsTUFBTSxZQUF5QixFQUFDLENBQUE7QUFFaEMsRUFBVyxRQUFBLEdBQUEsQ0FBQSxDQUFBO0FBQ1gsRUFBQSxLQUFBLE1BQVcsU0FBUyxJQUFNLEVBQUE7QUFDeEIsSUFBTSxNQUFBLFdBQUEsR0FBYyxLQUFLLFFBQVUsQ0FBQSxDQUFBLElBQUEsQ0FBQTtBQUNuQyxJQUFBLE1BQU0sU0FBa0IsRUFBQyxDQUFBO0FBRXpCLElBQVcsS0FBQSxNQUFBLEtBQUEsSUFBUyxNQUFNLE1BQVEsRUFBQTtBQUNoQyxNQUFBLE1BQU0sU0FBUyxFQUFDLENBQUE7QUFFaEIsTUFBQSxLQUFBLElBQVMsS0FBUSxHQUFBLENBQUEsRUFBRyxLQUFRLEdBQUEsS0FBQSxDQUFNLFFBQVEsS0FBUyxFQUFBLEVBQUE7QUFDakQsUUFBQSxJQUFJLElBQUssQ0FBQSxRQUFBLENBQUEsQ0FBVSxHQUFJLENBQUEsS0FBSyxDQUFHLEVBQUE7QUFDN0IsVUFBTyxNQUFBLENBQUEsSUFBQSxDQUFLLEtBQU0sQ0FBQSxNQUFBLENBQU8sS0FBTSxDQUFBLENBQUEsQ0FBQTtBQUMvQixVQUFBLFNBQUE7QUFBQSxTQUNGO0FBQUEsT0FDRjtBQUVBLE1BQU8sTUFBQSxDQUFBLElBQUEsQ0FBSyxpQ0FDUCxLQURPLENBQUEsRUFBQTtBQUFBLFFBRVYsTUFBUSxFQUFBLE1BQUE7QUFBQSxPQUNULENBQUEsQ0FBQSxDQUFBO0FBQUEsS0FDSDtBQUVBLElBQVUsU0FBQSxDQUFBLElBQUEsQ0FBSyxpQ0FDVixLQURVLENBQUEsRUFBQTtBQUFBLE1BRWIsTUFBQTtBQUFBLE1BQ0EsTUFBUSxFQUFBLFdBQUE7QUFBQSxLQUNULENBQUEsQ0FBQSxDQUFBO0FBQ0QsSUFBQSxRQUFBLEVBQUEsQ0FBQTtBQUFBLEdBQ0Y7QUFFQSxFQUFPLE9BQUEsU0FBQSxDQUFBO0FBQ1Q7Ozs7In0=

package/dist/esm/src/querying/layers/annotations/standardAnnotationQuery.js

@@ -0,0 +1,121 @@
+import { from, of } from 'rxjs';
+import { map, mergeMap } from 'rxjs/operators';
+import { rangeUtil, CoreApp, DataTopic } from '@grafana/data';
+import { getTemplateSrv, getRunRequest } from '@grafana/runtime';
+import { shouldUseLegacyRunner, standardAnnotationSupport } from './standardAnnotationsSupport.js';
+import { LoadingState } from '@grafana/schema';
+import { getEnrichedDataRequest } from '../../getEnrichedDataRequest.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));
+let counter = 100;
+function getNextRequestId() {
+  return "AQ" + counter++;
+}
+function executeAnnotationQuery(datasource, timeRange, query, layer) {
+  var _a;
+  if (datasource.annotationQuery && shouldUseLegacyRunner(datasource)) {
+    console.warn("Using deprecated annotationQuery method, please upgrade your datasource");
+    return from(
+      datasource.annotationQuery({
+        range: timeRange.state.value,
+        rangeRaw: timeRange.state.value.raw,
+        annotation: query,
+        dashboard: {
+          getVariables: getTemplateSrv().getVariables
+        }
+      })
+    ).pipe(
+      map((events) => ({
+        state: LoadingState.Done,
+        events
+      }))
+    );
+  }
+  const processor = __spreadValues(__spreadValues({}, standardAnnotationSupport), datasource.annotations);
+  const annotationWithDefaults = __spreadValues(__spreadValues({}, (_a = processor.getDefaultQuery) == null ? void 0 : _a.call(processor)), query);
+  const annotation = processor.prepareAnnotation(annotationWithDefaults);
+  if (!annotation) {
+    return of({
+      state: LoadingState.Done,
+      events: []
+    });
+  }
+  const processedQuery = processor.prepareQuery(annotation);
+  if (!processedQuery) {
+    return of({
+      state: LoadingState.Done,
+      events: []
+    });
+  }
+  const maxDataPoints = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
+  const interval = rangeUtil.calculateInterval(timeRange.state.value, maxDataPoints, datasource.interval);
+  const scopedVars = {
+    __interval: { text: interval.interval, value: interval.interval },
+    __interval_ms: { text: interval.intervalMs.toString(), value: interval.intervalMs },
+    __annotation: { text: annotation.name, value: annotation },
+    __sceneObject: wrapInSafeSerializableSceneObject(layer)
+  };
+  const queryRequest = __spreadValues(__spreadProps(__spreadValues({
+    startTime: Date.now(),
+    requestId: getNextRequestId(),
+    range: timeRange.state.value,
+    maxDataPoints,
+    scopedVars
+  }, interval), {
+    app: CoreApp.Dashboard,
+    timezone: timeRange.getTimeZone(),
+    targets: [
+      __spreadProps(__spreadValues({}, processedQuery), {
+        refId: "Anno"
+      })
+    ]
+  }), getEnrichedDataRequest(layer));
+  const runRequest = getRunRequest();
+  return runRequest(datasource, queryRequest).pipe(
+    mergeMap((panelData) => {
+      const data = (panelData == null ? void 0 : panelData.series.length) ? panelData.series : panelData.annotations;
+      if (!(data == null ? void 0 : data.length)) {
+        return of({
+          state: panelData.state,
+          events: []
+        });
+      }
+      data.forEach((frame) => {
+        var _a2;
+        if (!((_a2 = frame.meta) == null ? void 0 : _a2.dataTopic)) {
+          frame.meta = __spreadProps(__spreadValues({}, frame.meta || {}), { dataTopic: DataTopic.Annotations });
+        }
+      });
+      return processor.processEvents(annotation, data).pipe(
+        map((events) => {
+          return {
+            state: panelData.state,
+            events: events || []
+          };
+        })
+      );
+    })
+  );
+}
+
+export { executeAnnotationQuery };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"standardAnnotationQuery.js","sources":["../../../../../../src/querying/layers/annotations/standardAnnotationQuery.ts"],"sourcesContent":["import { from, Observable, of } from 'rxjs';\nimport { map, mergeMap } from 'rxjs/operators';\n\nimport {\n  AnnotationEvent,\n  AnnotationQuery,\n  CoreApp,\n  DataQueryRequest,\n  DataSourceApi,\n  DataTopic,\n  PanelModel,\n  rangeUtil,\n  ScopedVars,\n} from '@grafana/data';\n\nimport { getRunRequest, getTemplateSrv } from '@grafana/runtime';\nimport { shouldUseLegacyRunner, standardAnnotationSupport } from './standardAnnotationsSupport';\nimport { Dashboard, LoadingState } from '@grafana/schema';\nimport { SceneObject, SceneTimeRangeLike } from '../../../core/types';\nimport { getEnrichedDataRequest } from '../../getEnrichedDataRequest';\nimport { wrapInSafeSerializableSceneObject } from '../../../utils/wrapInSafeSerializableSceneObject';\n\nlet counter = 100;\nfunction getNextRequestId() {\n  return 'AQ' + counter++;\n}\n\nexport interface AnnotationQueryOptions {\n  dashboard: Dashboard;\n  panel: PanelModel;\n}\n\nexport interface AnnotationQueryResults {\n  state: LoadingState;\n  events: AnnotationEvent[];\n}\n\nexport function executeAnnotationQuery(\n  datasource: DataSourceApi,\n  timeRange: SceneTimeRangeLike,\n  query: AnnotationQuery,\n  layer: SceneObject\n): Observable<AnnotationQueryResults> {\n  // Check if we should use the old annotationQuery method\n  if (datasource.annotationQuery && shouldUseLegacyRunner(datasource)) {\n    console.warn('Using deprecated annotationQuery method, please upgrade your datasource');\n    return from(\n      datasource.annotationQuery({\n        range: timeRange.state.value,\n        rangeRaw: timeRange.state.value.raw,\n        annotation: query,\n        dashboard: {\n          getVariables: getTemplateSrv().getVariables,\n        },\n      })\n    ).pipe(\n      map((events) => ({\n        state: LoadingState.Done,\n        events,\n      }))\n    );\n  }\n\n  // Standard API for annotations support. Spread in datasource annotations support overrides\n  const processor = {\n    ...standardAnnotationSupport,\n    ...datasource.annotations,\n  };\n\n  const annotationWithDefaults = {\n    // Default query provided by a data source\n    ...processor.getDefaultQuery?.(),\n    ...query,\n  };\n\n  // Data source query migrations\n  const annotation = processor.prepareAnnotation!(annotationWithDefaults);\n  if (!annotation) {\n    return of({\n      state: LoadingState.Done,\n      events: [],\n    });\n  }\n\n  const processedQuery = processor.prepareQuery!(annotation);\n  if (!processedQuery) {\n    return of({\n      state: LoadingState.Done,\n      events: [],\n    });\n  }\n\n  // No more points than pixels\n  const maxDataPoints = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;\n\n  // Add interval to annotation queries\n  const interval = rangeUtil.calculateInterval(timeRange.state.value, maxDataPoints, datasource.interval);\n\n  const scopedVars: ScopedVars = {\n    __interval: { text: interval.interval, value: interval.interval },\n    __interval_ms: { text: interval.intervalMs.toString(), value: interval.intervalMs },\n    __annotation: { text: annotation.name, value: annotation },\n    __sceneObject: wrapInSafeSerializableSceneObject(layer),\n  };\n\n  const queryRequest: DataQueryRequest = {\n    startTime: Date.now(),\n    requestId: getNextRequestId(),\n    range: timeRange.state.value,\n    maxDataPoints,\n    scopedVars,\n    ...interval,\n    app: CoreApp.Dashboard,\n    timezone: timeRange.getTimeZone(),\n    targets: [\n      {\n        ...processedQuery,\n        refId: 'Anno',\n      },\n    ],\n    ...getEnrichedDataRequest(layer),\n  };\n\n  const runRequest = getRunRequest();\n\n  return runRequest(datasource, queryRequest).pipe(\n    mergeMap((panelData) => {\n      // Some annotations set the topic already\n      const data = panelData?.series.length ? panelData.series : panelData.annotations;\n\n      if (!data?.length) {\n        return of({\n          state: panelData.state,\n          events: [],\n        });\n      }\n\n      // Add data topic to each frame\n      data.forEach((frame) => {\n        // If data topic has not been provided by the data source, make sure it's set correctly\n        if (!frame.meta?.dataTopic) {\n          frame.meta = { ...(frame.meta || {}), dataTopic: DataTopic.Annotations };\n        }\n      });\n\n      return processor.processEvents!(annotation, data).pipe(\n        map((events) => {\n          return {\n            state: panelData.state,\n            events: events || [],\n          };\n        })\n      );\n    })\n  );\n}\n"],"names":["_a"],"mappings":"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"}