@grafana/scenes 6.7.0 → 6.8.0

package/dist/esm/dist/esm/querying/extraQueryProcessingOperator.js

@@ -0,0 +1,46 @@
+import { of, mergeMap, forkJoin, map } from 'rxjs';
+
+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 passthroughProcessor = (_, secondary) => of(secondary);
+const extraQueryProcessingOperator = (processors) => (data) => {
+  return data.pipe(
+    mergeMap(([primary, ...secondaries]) => {
+      const processedSecondaries = secondaries.flatMap((s) => {
+        var _a, _b;
+        return (_b = (_a = processors.get(s.request.requestId)) == null ? void 0 : _a(primary, s)) != null ? _b : of(s);
+      });
+      return forkJoin([of(primary), ...processedSecondaries]);
+    }),
+    map(([primary, ...processedSecondaries]) => {
+      var _a;
+      return __spreadProps(__spreadValues({}, primary), {
+        series: [...primary.series, ...processedSecondaries.flatMap((s) => s.series)],
+        annotations: [...(_a = primary.annotations) != null ? _a : [], ...processedSecondaries.flatMap((s) => {
+          var _a2;
+          return (_a2 = s.annotations) != null ? _a2 : [];
+        })]
+      });
+    })
+  );
+};
+
+export { extraQueryProcessingOperator, passthroughProcessor };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"extraQueryProcessingOperator.js","sources":["../../../querying/extraQueryProcessingOperator.js"],"sourcesContent":["import { of, mergeMap, forkJoin, map } from 'rxjs';\n\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nconst passthroughProcessor = (_, secondary) => of(secondary);\nconst extraQueryProcessingOperator = (processors) => (data) => {\n  return data.pipe(\n    mergeMap(([primary, ...secondaries]) => {\n      const processedSecondaries = secondaries.flatMap((s) => {\n        var _a, _b;\n        return (_b = (_a = processors.get(s.request.requestId)) == null ? void 0 : _a(primary, s)) != null ? _b : of(s);\n      });\n      return forkJoin([of(primary), ...processedSecondaries]);\n    }),\n    map(([primary, ...processedSecondaries]) => {\n      var _a;\n      return __spreadProps(__spreadValues({}, primary), {\n        series: [...primary.series, ...processedSecondaries.flatMap((s) => s.series)],\n        annotations: [...(_a = primary.annotations) != null ? _a : [], ...processedSecondaries.flatMap((s) => {\n          var _a2;\n          return (_a2 = s.annotations) != null ? _a2 : [];\n        })]\n      });\n    })\n  );\n};\n\nexport { extraQueryProcessingOperator, passthroughProcessor };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n"],"names":["_a"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAKO,MAAM,oBAAgD,GAAA,CAAC,CAAG,EAAA,SAAA,KAAc,GAAG,SAAS,EAAA;AAWpF,MAAM,4BACX,GAAA,CAAC,UAAqD,KAAA,CAAC,IAAkD,KAAA;AACvG,EAAA,OAAO,IAAK,CAAA,IAAA;AACV,IAAA,QAAA,CAAS,CAAC,CAAC,OAAY,EAAA,GAAA,WAAW,CAAM,KAAA;AACtC,MAAA,MAAM,oBAAuB,GAAA,WAAA,CAAY,OAAQ,CAAA,CAAC,CAAM,KAAA;AApBhE,QAAA,IAAA,EAAA,EAAA,EAAA,CAAA;AAqBiB,QAAA,OAAA,CAAA,MAAA,EAAA,GAAA,UAAA,CAAW,GAAI,CAAA,CAAA,CAAE,QAAS,SAAS,CAAA,KAAnC,IAAA,GAAA,KAAA,CAAA,GAAA,GAAuC,OAAS,EAAA,CAAA,MAAhD,IAAsD,GAAA,EAAA,GAAA,GAAG,CAAC,CAAA,CAAA;OAClE,CAAA,CAAA;AACD,MAAA,OAAO,SAAS,CAAC,EAAA,CAAG,OAAO,CAAG,EAAA,GAAG,oBAAoB,CAAC,CAAA,CAAA;KACvD,CAAA;AACD,IAAA,GAAA,CAAI,CAAC,CAAC,OAAY,EAAA,GAAA,oBAAoB,CAAG,KAAA;AAzB/C,MAAA,IAAA,EAAA,CAAA;AAyBmD,MAAA,OAAA,aAAA,CAAA,cAAA,CAAA,EAAA,EACxC,OADwC,CAAA,EAAA;QAE3C,MAAQ,EAAA,CAAC,GAAG,OAAA,CAAQ,MAAQ,EAAA,GAAG,oBAAqB,CAAA,OAAA,CAAQ,CAAC,CAAA,KAAM,CAAE,CAAA,MAAM,CAAC,CAAA;AAC5E,QAAA,WAAA,EAAa,CAAC,GAAA,CAAI,EAAA,GAAA,OAAA,CAAQ,WAAR,KAAA,IAAA,GAAA,EAAuB,GAAA,EAAK,EAAA,GAAG,oBAAqB,CAAA,OAAA,CAAQ,CAAC,CAAG,KAAA;AA5B1FA,UAAAA,IAAAA,GAAAA,CAAAA;AA4B6F,UAAA,OAAA,CAAAA,GAAA,GAAA,CAAA,CAAE,WAAF,KAAA,IAAA,GAAAA,MAAiB,EAAA,CAAA;AAAC,SAAC,CAAC,CAAA;OAC3G,CAAA,CAAA;KAAE,CAAA;AAAA,GAAA,CAAA;AAEN;;;;"}

package/dist/esm/dist/esm/querying/getEnrichedDataRequest.js

@@ -0,0 +1,12 @@
+import { isDataRequestEnricher } from '../core/types.js';
+
+function getEnrichedDataRequest(sourceRunner) {
+  const root = sourceRunner.getRoot();
+  if (isDataRequestEnricher(root)) {
+    return root.enrichDataRequest(sourceRunner);
+  }
+  return null;
+}
+
+export { getEnrichedDataRequest };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/dist/esm/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":["../../../../querying/layers/SceneDataLayerBase.js"],"sourcesContent":["import { ReplaySubject } from 'rxjs';\nimport { emptyPanelData } from '../../core/SceneDataNode.js';\nimport { SceneObjectBase } from '../../core/SceneObjectBase.js';\nimport { setBaseClassState } from '../../utils/utils.js';\nimport { writeSceneLog } from '../../utils/writeSceneLog.js';\nimport { VariableDependencyConfig } from '../../variables/VariableDependencyConfig.js';\nimport { VariableValueRecorder } from '../../variables/VariableValueRecorder.js';\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nclass SceneDataLayerBase extends SceneObjectBase {\n  constructor(initialState, variableDependencyStatePaths = []) {\n    super(__spreadValues({\n      isEnabled: true\n    }, initialState));\n    this._results = new ReplaySubject(1);\n    this.isDataLayer = true;\n    this._variableValueRecorder = new VariableValueRecorder();\n    this._variableDependency = new VariableDependencyConfig(this, {\n      onVariableUpdateCompleted: this.onVariableUpdateCompleted.bind(this)\n    });\n    this._variableDependency.setPaths(variableDependencyStatePaths);\n    this.addActivationHandler(() => this.onActivate());\n  }\n  onActivate() {\n    if (this.state.isEnabled) {\n      this.onEnable();\n    }\n    if (this.shouldRunLayerOnActivate()) {\n      this.runLayer();\n    }\n    this.subscribeToState((n, p) => {\n      if (!n.isEnabled && this.querySub) {\n        this.querySub.unsubscribe();\n        this.querySub = void 0;\n        this.onDisable();\n        this._results.next({ origin: this, data: emptyPanelData });\n        this.setStateHelper({ data: emptyPanelData });\n      }\n      if (n.isEnabled && !p.isEnabled) {\n        this.onEnable();\n        this.runLayer();\n      }\n    });\n    return () => {\n      this.onDeactivate();\n    };\n  }\n  onDeactivate() {\n    if (this.querySub) {\n      this.querySub.unsubscribe();\n      this.querySub = void 0;\n    }\n    this.onDisable();\n    this._variableValueRecorder.recordCurrentDependencyValuesForSceneObject(this);\n  }\n  onVariableUpdateCompleted() {\n    this.runLayer();\n  }\n  cancelQuery() {\n    if (this.querySub) {\n      this.querySub.unsubscribe();\n      this.querySub = void 0;\n      this.publishResults(emptyPanelData);\n    }\n  }\n  publishResults(data) {\n    if (this.state.isEnabled) {\n      this._results.next({ origin: this, data });\n      this.setStateHelper({ data });\n    }\n  }\n  getResultsStream() {\n    return this._results;\n  }\n  shouldRunLayerOnActivate() {\n    if (!this.state.isEnabled) {\n      return false;\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    if (!this.state.data) {\n      return true;\n    }\n    return false;\n  }\n  setStateHelper(state) {\n    setBaseClassState(this, state);\n  }\n}\n\nexport { SceneDataLayerBase };\n//# 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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"}\n"],"names":[],"mappings":"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"}

package/dist/esm/dist/esm/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,{"version":3,"file":"SceneDataLayerControls.js","sources":["../../../../querying/layers/SceneDataLayerControls.js"],"sourcesContent":["import { css } from '@emotion/css';\nimport { LoadingState } from '@grafana/schema';\nimport { InlineSwitch } from '@grafana/ui';\nimport React from 'react';\nimport { sceneGraph } from '../../core/sceneGraph/index.js';\nimport { SceneObjectBase } from '../../core/SceneObjectBase.js';\nimport { ControlsLabel } from '../../utils/ControlsLabel.js';\n\nclass SceneDataLayerControls extends SceneObjectBase {\n  constructor() {\n    super({});\n  }\n}\nSceneDataLayerControls.Component = SceneDataLayerControlsRenderer;\nfunction SceneDataLayerControlsRenderer({ model }) {\n  const layers = sceneGraph.getDataLayers(model, true);\n  if (layers.length === 0) {\n    return null;\n  }\n  return /* @__PURE__ */ React.createElement(React.Fragment, null, layers.map((layer) => /* @__PURE__ */ React.createElement(layer.Component, {\n    model: layer,\n    key: layer.state.key\n  })));\n}\nfunction DataLayerControlSwitch({ layer }) {\n  var _a, _b;\n  const elementId = `data-layer-${layer.state.key}`;\n  const { data, isEnabled } = layer.useState();\n  const showLoading = Boolean(data && data.state === LoadingState.Loading);\n  return /* @__PURE__ */ React.createElement(\"div\", {\n    className: containerStyle\n  }, /* @__PURE__ */ React.createElement(ControlsLabel, {\n    htmlFor: elementId,\n    isLoading: showLoading,\n    onCancel: () => {\n      var _a2;\n      return (_a2 = layer.cancelQuery) == null ? void 0 : _a2.call(layer);\n    },\n    label: layer.state.name,\n    description: layer.state.description,\n    error: (_b = (_a = layer.state.data) == null ? void 0 : _a.errors) == null ? void 0 : _b[0].message\n  }), /* @__PURE__ */ React.createElement(InlineSwitch, {\n    id: elementId,\n    value: isEnabled,\n    onChange: () => layer.setState({ isEnabled: !isEnabled })\n  }));\n}\nconst containerStyle = css({ display: \"flex\" });\n\nexport { DataLayerControlSwitch, SceneDataLayerControls };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n"],"names":["_a"],"mappings":";;;;;;;;AAWO,MAAM,+BAA+B,eAA6C,CAAA;EAGhF,WAAc,GAAA;AACnB,IAAA,KAAA,CAAM,EAAE,CAAA,CAAA;AAAA,GAAA;AAEZ,CAAA;AANa,sBAAA,CACG,SAAY,GAAA,8BAAA,CAAA;AAO5B,SAAS,8BAAA,CAA+B,EAAE,KAAA,EAAsD,EAAA;AAC9F,EAAA,MAAM,MAAS,GAAA,UAAA,CAAW,aAAc,CAAA,KAAA,EAAO,IAAI,CAAA,CAAA;AAE/C,EAAA,IAAA,MAAA,CAAO,WAAW,CAAG,EAAA;AAChB,IAAA,OAAA,IAAA,CAAA;AAAA,GAAA;AAGT,EAAA,uBAAA,KAAA,CAAA,aAAA,CAAA,KAAA,CAAA,QAAA,EAAA,IAEK,EAAA,MAAA,CAAO,GAAI,CAAA,CAAC,KACX,qBAAA,KAAA,CAAA,aAAC,CAAA,KAAA,CAAM,SAAN,EAAA;IAAgB,KAAO,EAAA,KAAA;AAAO,IAAA,GAAA,EAAK,MAAM,KAAM,CAAA,GAAA;AAAA,GAAK,CACtD,CACH,CAAA,CAAA;AAEJ,CAAA;AAMgB,SAAA,sBAAA,CAAuB,EAAE,KAAA,EAAqC,EAAA;AAvC9E,EAAA,IAAA,EAAA,EAAA,EAAA,CAAA;AAwCQ,EAAA,MAAA,SAAA,GAAY,CAAc,WAAA,EAAA,KAAA,CAAM,KAAM,CAAA,GAAA,CAAA,CAAA,CAAA;AAC5C,EAAA,MAAM,EAAE,IAAA,EAAM,SAAU,EAAA,GAAI,MAAM,QAAS,EAAA,CAAA;AAC3C,EAAA,MAAM,cAAc,OAAQ,CAAA,IAAA,IAAQ,IAAK,CAAA,KAAA,KAAU,aAAa,OAAO,CAAA,CAAA;AAEvE,EACG,uBAAA,KAAA,CAAA,cAAA,KAAA,EAAA;IAAI,SAAW,EAAA,cAAA;GACb,kBAAA,KAAA,CAAA,cAAA,aAAA,EAAA;IACC,OAAS,EAAA,SAAA;IACT,SAAW,EAAA,WAAA;AACX,IAAA,QAAA,EAAU,MAAG;AAjDrBA,MAAAA,IAAAA,GAAAA,CAAAA;AAiDwB,MAAA,OAAA,CAAAA,MAAA,KAAM,CAAA,WAAA,KAAN,OAAA,KAAAA,CAAAA,GAAAA,GAAAA,CAAA,KAAA,KAAA,CAAA,CAAA;AAAA,KAAA;AAChB,IAAA,KAAA,EAAO,MAAM,KAAM,CAAA,IAAA;AACnB,IAAA,WAAA,EAAa,MAAM,KAAM,CAAA,WAAA;AACzB,IAAA,KAAA,EAAA,CAAO,EAAM,GAAA,CAAA,EAAA,GAAA,KAAA,CAAA,KAAA,CAAM,IAAZ,KAAA,IAAA,GAAkB,KAAA,CAAA,GAAA,EAAA,CAAA,MAAlB,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAA2B,CAAG,CAAA,CAAA,OAAA;GACvC,CAAA,kBACC,KAAA,CAAA,aAAA,CAAA,YAAA,EAAA;IAAa,EAAI,EAAA,SAAA;IAAW,KAAO,EAAA,SAAA;AAAW,IAAA,QAAA,EAAU,MAAM,KAAM,CAAA,QAAA,CAAS,EAAE,SAAW,EAAA,CAAC,WAAW,CAAA;AAAA,GAAG,CAC5G,CAAA,CAAA;AAEJ,CAAA;AAEA,MAAM,cAAiB,GAAA,GAAA,CAAI,EAAE,OAAA,EAAS,QAAQ,CAAA;;;;"}

package/dist/esm/dist/esm/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":["../../../../../querying/layers/annotations/AnnotationsDataLayer.js"],"sourcesContent":["import { arrayToDataFrame, DataTopic } from '@grafana/data';\nimport { LoadingState } from '@grafana/schema';\nimport React from 'react';\nimport { map } from 'rxjs';\nimport { emptyPanelData } from '../../../core/SceneDataNode.js';\nimport { sceneGraph } from '../../../core/sceneGraph/index.js';\nimport { getDataSource } from '../../../utils/getDataSource.js';\nimport { getMessageFromError } from '../../../utils/getMessageFromError.js';\nimport { writeSceneLog } from '../../../utils/writeSceneLog.js';\nimport { registerQueryWithController } from '../../registerQueryWithController.js';\nimport { SceneDataLayerBase } from '../SceneDataLayerBase.js';\nimport { DataLayerControlSwitch } from '../SceneDataLayerControls.js';\nimport { executeAnnotationQuery } from './standardAnnotationQuery.js';\nimport { postProcessQueryResult, dedupAnnotations } from './utils.js';\nimport { wrapInSafeSerializableSceneObject } from '../../../utils/wrapInSafeSerializableSceneObject.js';\nimport { RefreshEvent } from '@grafana/runtime';\n\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nclass AnnotationsDataLayer extends SceneDataLayerBase {\n  constructor(initialState) {\n    super(\n      __spreadValues({\n        isEnabled: true\n      }, initialState),\n      [\"query\"]\n    );\n    this._scopedVars = {\n      __sceneObject: wrapInSafeSerializableSceneObject(this)\n    };\n  }\n  onEnable() {\n    this.publishEvent(new RefreshEvent(), true);\n    const timeRange = sceneGraph.getTimeRange(this);\n    this._timeRangeSub = timeRange.subscribeToState(() => {\n      this.runWithTimeRange(timeRange);\n    });\n  }\n  onDisable() {\n    var _a;\n    this.publishEvent(new RefreshEvent(), true);\n    (_a = this._timeRangeSub) == null ? void 0 : _a.unsubscribe();\n  }\n  runLayer() {\n    writeSceneLog(\"AnnotationsDataLayer\", \"run layer\");\n    const timeRange = sceneGraph.getTimeRange(this);\n    this.runWithTimeRange(timeRange);\n  }\n  async runWithTimeRange(timeRange) {\n    const { query } = this.state;\n    if (this.querySub) {\n      this.querySub.unsubscribe();\n    }\n    if (this._variableDependency.hasDependencyInLoadingState()) {\n      writeSceneLog(\"AnnotationsDataLayer\", \"Variable dependency is in loading state, skipping query execution\");\n      return;\n    }\n    try {\n      const ds = await this.resolveDataSource(query);\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      this.querySub = stream.subscribe((stateUpdate) => {\n        this.publishResults(stateUpdate);\n      });\n    } catch (e) {\n      this.publishResults(__spreadProps(__spreadValues({}, emptyPanelData), {\n        state: LoadingState.Error,\n        errors: [\n          {\n            message: getMessageFromError(e)\n          }\n        ]\n      }));\n      console.error(\"AnnotationsDataLayer error\", e);\n    }\n  }\n  async resolveDataSource(query) {\n    return await getDataSource(query.datasource || void 0, this._scopedVars);\n  }\n  processEvents(query, events) {\n    let processedEvents = postProcessQueryResult(query, events.events || []);\n    processedEvents = dedupAnnotations(processedEvents);\n    const stateUpdate = __spreadProps(__spreadValues({}, emptyPanelData), { state: events.state });\n    const df = arrayToDataFrame(processedEvents);\n    df.meta = __spreadProps(__spreadValues({}, df.meta), {\n      dataTopic: DataTopic.Annotations\n    });\n    stateUpdate.series = [df];\n    return stateUpdate;\n  }\n}\nAnnotationsDataLayer.Component = AnnotationsDataLayerRenderer;\nfunction AnnotationsDataLayerRenderer({ model }) {\n  const { isHidden } = model.useState();\n  if (isHidden) {\n    return null;\n  }\n  return /* @__PURE__ */ React.createElement(DataLayerControlSwitch, {\n    layer: model\n  });\n}\n\nexport { AnnotationsDataLayer };\n//# 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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"}\n"],"names":[],"mappings":"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"}

package/dist/esm/dist/esm/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,{"version":3,"file":"filterAnnotations.js","sources":["../../../../../querying/layers/annotations/filterAnnotations.js"],"sourcesContent":["var __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nconst GLOBAL_ANNOTATION_ID = 0;\nfunction filterAnnotations(data, filters) {\n  var _a;\n  if (!Array.isArray(data) || data.length === 0) {\n    return data;\n  }\n  const rows = Array.from({ length: data.length }, () => /* @__PURE__ */ new Set());\n  let frameIdx = 0;\n  for (const frame of data) {\n    for (let index = 0; index < frame.length; index++) {\n      if (rows[frameIdx].has(index)) {\n        continue;\n      }\n      let matching = true;\n      const panelIdField = frame.fields.find((f) => f.name === \"panelId\");\n      const sourceField = frame.fields.find((f) => f.name === \"source\");\n      if (sourceField) {\n        if (panelIdField && sourceField.values[index].type === \"dashboard\") {\n          matching = [filters.panelId, GLOBAL_ANNOTATION_ID].includes(panelIdField.values[index]);\n        }\n        const sourceFilter = sourceField.values[index].filter;\n        if (sourceFilter) {\n          const includes = [...(_a = sourceFilter.ids) != null ? _a : [], GLOBAL_ANNOTATION_ID].includes(filters.panelId);\n          if (sourceFilter.exclude) {\n            if (includes) {\n              matching = false;\n            }\n          } else if (!includes) {\n            matching = false;\n          }\n        }\n      }\n      if (matching) {\n        rows[frameIdx].add(index);\n      }\n    }\n    frameIdx++;\n  }\n  const processed = [];\n  frameIdx = 0;\n  for (const frame of data) {\n    const frameLength = rows[frameIdx].size;\n    const fields = [];\n    for (const field of frame.fields) {\n      const buffer = [];\n      for (let index = 0; index < frame.length; index++) {\n        if (rows[frameIdx].has(index)) {\n          buffer.push(field.values[index]);\n          continue;\n        }\n      }\n      fields.push(__spreadProps(__spreadValues({}, field), {\n        values: buffer\n      }));\n    }\n    processed.push(__spreadProps(__spreadValues({}, frame), {\n      fields,\n      length: frameLength\n    }));\n    frameIdx++;\n  }\n  return processed;\n}\n\nexport { filterAnnotations };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n"],"names":[],"mappings":"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"}