@grafana/scenes 6.7.0--canary.1091.14350229100.0 → 6.8.0

package/dist/esm/src/querying/DataLayersMerger.js

@@ -0,0 +1,46 @@
+import { merge, mergeAll, filter, map, finalize } from 'rxjs';
+
+class DataLayersMerger {
+  constructor() {
+    this._resultsMap = /* @__PURE__ */ new Map();
+    this._prevLayers = [];
+  }
+  getMergedStream(layers) {
+    if (areDifferentLayers(layers, this._prevLayers)) {
+      this._resultsMap = /* @__PURE__ */ new Map();
+      this._prevLayers = layers;
+    }
+    const resultStreams = layers.map((l) => l.getResultsStream());
+    const deactivationHandlers = [];
+    for (const layer of layers) {
+      deactivationHandlers.push(layer.activate());
+    }
+    return merge(resultStreams).pipe(
+      mergeAll(),
+      filter((v) => {
+        return this._resultsMap.get(v.origin.state.key) !== v;
+      }),
+      map((v) => {
+        this._resultsMap.set(v.origin.state.key, v);
+        return this._resultsMap.values();
+      }),
+      finalize(() => {
+        deactivationHandlers.forEach((handler) => handler());
+      })
+    );
+  }
+}
+function areDifferentLayers(a, b) {
+  if (a.length !== b.length) {
+    return true;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export { DataLayersMerger };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/querying/DataProviderProxy.js

@@ -0,0 +1,37 @@
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+
+class DataProviderProxy extends SceneObjectBase {
+  constructor(state) {
+    super({
+      source: state.source,
+      data: state.source.resolve().state.data
+    });
+    this.addActivationHandler(() => {
+      this._subs.add(
+        this.state.source.resolve().subscribeToState((newState, oldState) => {
+          if (newState.data !== oldState.data) {
+            this.setState({ data: newState.data });
+          }
+        })
+      );
+    });
+  }
+  setContainerWidth(width) {
+    var _a, _b;
+    (_b = (_a = this.state.source.resolve()).setContainerWidth) == null ? void 0 : _b.call(_a, width);
+  }
+  isDataReadyToDisplay() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.state.source.resolve()).isDataReadyToDisplay) == null ? void 0 : _b.call(_a)) != null ? _c : true;
+  }
+  cancelQuery() {
+    var _a, _b;
+    (_b = (_a = this.state.source.resolve()).cancelQuery) == null ? void 0 : _b.call(_a);
+  }
+  getResultsStream() {
+    return this.state.source.resolve().getResultsStream();
+  }
+}
+
+export { DataProviderProxy };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/querying/DataProviderSharer.js

@@ -0,0 +1,108 @@
+import 'react';
+import 'react-router-dom';
+import '@grafana/data';
+import '@grafana/runtime';
+import { SceneObjectBase } from '../../dist/esm/core/SceneObjectBase.js';
+import '../../dist/esm/core/SceneObjectRef.js';
+import 'lodash';
+import '../../dist/esm/variables/interpolation/defaults.js';
+import '@grafana/schema';
+import '../../dist/esm/variables/types.js';
+import '../../dist/esm/variables/interpolation/formatRegistry.js';
+import '../../dist/esm/variables/macros/index.js';
+import '../../dist/esm/variables/variants/query/QueryVariable.js';
+import 'rxjs';
+import '../../dist/esm/core/SceneDataNode.js';
+import '../../dist/esm/variables/groupby/GroupByVariable.js';
+import '../../dist/esm/variables/adhoc/AdHocFiltersVariable.js';
+import '../../dist/esm/utils/SafeSerializableSceneObject.js';
+import '../../dist/esm/core/events.js';
+import '../../dist/esm/behaviors/LiveNowTimer.js';
+import '../../dist/esm/querying/layers/annotations/AnnotationsDataLayer.js';
+import '../../dist/esm/querying/SceneDataLayerSet.js';
+import '../../dist/esm/querying/layers/SceneDataLayerControls.js';
+import '../../dist/esm/variables/components/VariableValueSelectors.js';
+import '../../dist/esm/variables/components/VariableValueControl.js';
+import '../../dist/esm/variables/variants/CustomVariable.js';
+import '../../dist/esm/variables/variants/DataSourceVariable.js';
+import '../../dist/esm/variables/variants/TestVariable.js';
+import '../../dist/esm/variables/variants/TextBoxVariable.js';
+import '../../dist/esm/variables/variants/IntervalVariable.js';
+import '../../dist/esm/services/UrlSyncManager.js';
+import '../../dist/esm/components/EmbeddedScene.js';
+import '../../dist/esm/components/VizPanel/VizPanel.js';
+import '../../dist/esm/components/VizPanel/VizPanelMenu.js';
+import '../../dist/esm/components/NestedScene.js';
+import '../../dist/esm/components/SceneCanvasText.js';
+import '../../dist/esm/components/SceneToolbarButton.js';
+import '../../dist/esm/components/SceneTimePicker.js';
+import '../../dist/esm/components/SceneRefreshPicker.js';
+import '../../dist/esm/components/SceneTimeRangeCompare.js';
+import '../../dist/esm/components/SceneByFrameRepeater.js';
+import '../../dist/esm/components/SceneByVariableRepeater.js';
+import '../../dist/esm/components/SceneControlsSpacer.js';
+import '../../dist/esm/components/layout/SceneFlexLayout.js';
+import '../../dist/esm/components/layout/CSSGrid/SceneCSSGridLayout.js';
+import '../../dist/esm/components/layout/grid/SceneGridLayout.js';
+import '../../dist/esm/components/layout/grid/SceneGridItem.js';
+import '../../dist/esm/components/layout/grid/SceneGridRow.js';
+import '../../dist/esm/components/layout/split/SplitLayout.js';
+import '../../dist/esm/components/SceneApp/SceneApp.js';
+import '../../dist/esm/components/SceneApp/SceneAppPage.js';
+import '../../dist/esm/components/SceneReactObject.js';
+import '@grafana/schema/dist/esm/raw/composable/barchart/panelcfg/x/BarChartPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/bargauge/panelcfg/x/BarGaugePanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/datagrid/panelcfg/x/DatagridPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/gauge/panelcfg/x/GaugePanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/geomap/panelcfg/x/GeomapPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/heatmap/panelcfg/x/HeatmapPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/histogram/panelcfg/x/HistogramPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/news/panelcfg/x/NewsPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/piechart/panelcfg/x/PieChartPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/stat/panelcfg/x/StatPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/statetimeline/panelcfg/x/StateTimelinePanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/statushistory/panelcfg/x/StatusHistoryPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/table/panelcfg/x/TablePanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/text/panelcfg/x/TextPanelCfg_types.gen';
+import '@grafana/schema/dist/esm/raw/composable/xychart/panelcfg/x/XYChartPanelCfg_types.gen';
+import '@emotion/css';
+import '@grafana/ui';
+import '../../dist/esm/variables/components/VariableValueSelect.js';
+
+class DataProviderSharer extends SceneObjectBase {
+  constructor(state) {
+    super({
+      source: state.source,
+      data: state.source.resolve().state.data,
+    });
+    this.addActivationHandler(() => {
+      this._subs.add(
+        this.state.source.resolve().subscribeToState((newState, oldState) => {
+          if (newState.data !== oldState.data) {
+            this.setState({ data: newState.data });
+          }
+        })
+      );
+    });
+  }
+  setContainerWidth(width) {
+    var _a, _b;
+    (_b = (_a = this.state.source.resolve()).setContainerWidth) == null ? void 0 : _b.call(_a, width);
+  }
+  isDataReadyToDisplay() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.state.source.resolve()).isDataReadyToDisplay) == null ? void 0 : _b.call(_a)) != null
+      ? _c
+      : true;
+  }
+  cancelQuery() {
+    var _a, _b;
+    (_b = (_a = this.state.source.resolve()).cancelQuery) == null ? void 0 : _b.call(_a);
+  }
+  getResultsStream() {
+    return this.state.source.resolve().getResultsStream();
+  }
+}
+
+export { DataProviderSharer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGF0YVByb3ZpZGVyU2hhcmVyLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcXVlcnlpbmcvRGF0YVByb3ZpZGVyU2hhcmVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIFNjZW5lT2JqZWN0QmFzZSxcbiAgU2NlbmVPYmplY3RSZWYsXG4gIFNjZW5lRGF0YVByb3ZpZGVyLFxuICBTY2VuZURhdGFQcm92aWRlclJlc3VsdCxcbiAgU2NlbmVEYXRhU3RhdGUsXG59IGZyb20gJ0BncmFmYW5hL3NjZW5lcyc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YVByb3ZpZGVyU2hhcmVyU3RhdGUgZXh0ZW5kcyBTY2VuZURhdGFTdGF0ZSB7XG4gIHNvdXJjZTogU2NlbmVPYmplY3RSZWY8U2NlbmVEYXRhUHJvdmlkZXI+O1xufVxuXG5leHBvcnQgY2xhc3MgRGF0YVByb3ZpZGVyU2hhcmVyIGV4dGVuZHMgU2NlbmVPYmplY3RCYXNlPERhdGFQcm92aWRlclNoYXJlclN0YXRlPiBpbXBsZW1lbnRzIFNjZW5lRGF0YVByb3ZpZGVyIHtcbiAgcHVibGljIGNvbnN0cnVjdG9yKHN0YXRlOiBEYXRhUHJvdmlkZXJTaGFyZXJTdGF0ZSkge1xuICAgIHN1cGVyKHtcbiAgICAgIHNvdXJjZTogc3RhdGUuc291cmNlLFxuICAgICAgZGF0YTogc3RhdGUuc291cmNlLnJlc29sdmUoKS5zdGF0ZS5kYXRhLFxuICAgIH0pO1xuXG4gICAgdGhpcy5hZGRBY3RpdmF0aW9uSGFuZGxlcigoKSA9PiB7XG4gICAgICB0aGlzLl9zdWJzLmFkZChcbiAgICAgICAgdGhpcy5zdGF0ZS5zb3VyY2UucmVzb2x2ZSgpLnN1YnNjcmliZVRvU3RhdGUoKG5ld1N0YXRlLCBvbGRTdGF0ZSkgPT4ge1xuICAgICAgICAgIGlmIChuZXdTdGF0ZS5kYXRhICE9PSBvbGRTdGF0ZS5kYXRhKSB7XG4gICAgICAgICAgICB0aGlzLnNldFN0YXRlKHsgZGF0YTogbmV3U3RhdGUuZGF0YSB9KTtcbiAgICAgICAgICB9XG4gICAgICAgIH0pXG4gICAgICApO1xuICAgIH0pO1xuICB9XG5cbiAgcHVibGljIHNldENvbnRhaW5lcldpZHRoKHdpZHRoOiBudW1iZXIpIHtcbiAgICB0aGlzLnN0YXRlLnNvdXJjZS5yZXNvbHZlKCkuc2V0Q29udGFpbmVyV2lkdGg/Lih3aWR0aCk7XG4gIH1cblxuICBwdWJsaWMgaXNEYXRhUmVhZHlUb0Rpc3BsYXkoKSB7XG4gICAgcmV0dXJuIHRoaXMuc3RhdGUuc291cmNlLnJlc29sdmUoKS5pc0RhdGFSZWFkeVRvRGlzcGxheT8uKCkgPz8gdHJ1ZTtcbiAgfVxuXG4gIHB1YmxpYyBjYW5jZWxRdWVyeSgpIHtcbiAgICB0aGlzLnN0YXRlLnNvdXJjZS5yZXNvbHZlKCkuY2FuY2VsUXVlcnk/LigpO1xuICB9XG5cbiAgcHVibGljIGdldFJlc3VsdHNTdHJlYW0oKTogT2JzZXJ2YWJsZTxTY2VuZURhdGFQcm92aWRlclJlc3VsdD4ge1xuICAgIHJldHVybiB0aGlzLnN0YXRlLnNvdXJjZS5yZXNvbHZlKCkuZ2V0UmVzdWx0c1N0cmVhbSgpO1xuICB9XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFhTyxNQUFNLDJCQUEyQixlQUFzRSxDQUFBO0FBQUEsRUFDckcsWUFBWSxLQUFnQyxFQUFBO0FBQ2pELElBQU0sS0FBQSxDQUFBO0FBQUEsTUFDSixRQUFRLEtBQU0sQ0FBQSxNQUFBO0FBQUEsTUFDZCxJQUFNLEVBQUEsS0FBQSxDQUFNLE1BQU8sQ0FBQSxPQUFBLEdBQVUsS0FBTSxDQUFBLElBQUE7QUFBQSxLQUNwQyxDQUFBLENBQUE7QUFFRCxJQUFBLElBQUEsQ0FBSyxxQkFBcUIsTUFBTTtBQUM5QixNQUFBLElBQUEsQ0FBSyxLQUFNLENBQUEsR0FBQTtBQUFBLFFBQ1QsSUFBQSxDQUFLLE1BQU0sTUFBTyxDQUFBLE9BQUEsR0FBVSxnQkFBaUIsQ0FBQSxDQUFDLFVBQVUsUUFBYSxLQUFBO0FBQ25FLFVBQUksSUFBQSxRQUFBLENBQVMsSUFBUyxLQUFBLFFBQUEsQ0FBUyxJQUFNLEVBQUE7QUFDbkMsWUFBQSxJQUFBLENBQUssUUFBUyxDQUFBLEVBQUUsSUFBTSxFQUFBLFFBQUEsQ0FBUyxNQUFNLENBQUEsQ0FBQTtBQUFBLFdBQ3ZDO0FBQUEsU0FDRCxDQUFBO0FBQUEsT0FDSCxDQUFBO0FBQUEsS0FDRCxDQUFBLENBQUE7QUFBQSxHQUNIO0FBQUEsRUFFTyxrQkFBa0IsS0FBZSxFQUFBO0FBL0IxQyxJQUFBLElBQUEsRUFBQSxFQUFBLEVBQUEsQ0FBQTtBQWdDSSxJQUFBLENBQUEsRUFBQSxHQUFBLENBQUEsRUFBQSxHQUFBLElBQUEsQ0FBSyxLQUFNLENBQUEsTUFBQSxDQUFPLE9BQVEsRUFBQSxFQUFFLHNCQUE1QixJQUFnRCxHQUFBLEtBQUEsQ0FBQSxHQUFBLEVBQUEsQ0FBQSxJQUFBLENBQUEsRUFBQSxFQUFBLEtBQUEsQ0FBQSxDQUFBO0FBQUEsR0FDbEQ7QUFBQSxFQUVPLG9CQUF1QixHQUFBO0FBbkNoQyxJQUFBLElBQUEsRUFBQSxFQUFBLEVBQUEsRUFBQSxFQUFBLENBQUE7QUFvQ0ksSUFBQSxPQUFBLENBQU8sc0JBQUssS0FBTSxDQUFBLE1BQUEsQ0FBTyxPQUFRLEVBQUEsRUFBRSx5QkFBNUIsSUFBd0QsR0FBQSxLQUFBLENBQUEsR0FBQSxFQUFBLENBQUEsSUFBQSxDQUFBLEVBQUEsQ0FBQSxLQUFBLElBQUEsR0FBQSxFQUFBLEdBQUEsSUFBQSxDQUFBO0FBQUEsR0FDakU7QUFBQSxFQUVPLFdBQWMsR0FBQTtBQXZDdkIsSUFBQSxJQUFBLEVBQUEsRUFBQSxFQUFBLENBQUE7QUF3Q0ksSUFBQSxDQUFBLEVBQUEsR0FBQSxDQUFBLEVBQUEsR0FBQSxJQUFBLENBQUssS0FBTSxDQUFBLE1BQUEsQ0FBTyxPQUFRLEVBQUEsRUFBRSxXQUE1QixLQUFBLElBQUEsR0FBQSxLQUFBLENBQUEsR0FBQSxFQUFBLENBQUEsSUFBQSxDQUFBLEVBQUEsQ0FBQSxDQUFBO0FBQUEsR0FDRjtBQUFBLEVBRU8sZ0JBQXdELEdBQUE7QUFDN0QsSUFBQSxPQUFPLElBQUssQ0FBQSxLQUFBLENBQU0sTUFBTyxDQUFBLE9BQUEsR0FBVSxnQkFBaUIsRUFBQSxDQUFBO0FBQUEsR0FDdEQ7QUFDRjs7OzsifQ==

package/dist/esm/src/querying/ExtraQueryProvider.js

@@ -0,0 +1,6 @@
+function isExtraQueryProvider(obj) {
+  return typeof obj === "object" && "getExtraQueries" in obj;
+}
+
+export { isExtraQueryProvider };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/querying/RuntimeDataSource.js

@@ -0,0 +1,49 @@
+import { DataSourceApi, PluginType } from '@grafana/data';
+
+class RuntimeDataSource extends DataSourceApi {
+  constructor(pluginId, uid) {
+    super({
+      name: "RuntimeDataSource-" + pluginId,
+      uid,
+      type: pluginId,
+      id: 1,
+      readOnly: true,
+      jsonData: {},
+      access: "direct",
+      meta: {
+        id: pluginId,
+        name: "RuntimeDataSource-" + pluginId,
+        type: PluginType.datasource,
+        info: {
+          author: {
+            name: ""
+          },
+          description: "",
+          links: [],
+          logos: {
+            large: "",
+            small: ""
+          },
+          screenshots: [],
+          updated: "",
+          version: ""
+        },
+        module: "",
+        baseUrl: ""
+      }
+    });
+  }
+  testDatasource() {
+    return Promise.resolve({});
+  }
+}
+const runtimeDataSources = /* @__PURE__ */ new Map();
+function registerRuntimeDataSource({ dataSource }) {
+  if (runtimeDataSources.has(dataSource.uid)) {
+    throw new Error(`A runtime data source with uid ${dataSource.uid} has already been registered`);
+  }
+  runtimeDataSources.set(dataSource.uid, dataSource);
+}
+
+export { RuntimeDataSource, registerRuntimeDataSource, runtimeDataSources };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/querying/SceneDataLayerSet.js

@@ -0,0 +1,100 @@
+import React from 'react';
+import { ReplaySubject } from 'rxjs';
+import { emptyPanelData } from '../core/SceneDataNode.js';
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+import { DataLayersMerger } from './DataLayersMerger.js';
+import { setBaseClassState } from '../utils/utils.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 SceneDataLayerSetBase extends SceneObjectBase {
+  constructor() {
+    super(...arguments);
+    this.isDataLayer = true;
+    this._results = new ReplaySubject(1);
+    this._dataLayersMerger = new DataLayersMerger();
+  }
+  subscribeToAllLayers(layers) {
+    if (layers.length > 0) {
+      this.querySub = this._dataLayersMerger.getMergedStream(layers).subscribe(this._onLayerUpdateReceived.bind(this));
+    } else {
+      this._results.next({ origin: this, data: emptyPanelData });
+      this.setStateHelper({ data: emptyPanelData });
+    }
+  }
+  _onLayerUpdateReceived(results) {
+    var _a;
+    let series = [];
+    for (const result of results) {
+      if ((_a = result.data) == null ? void 0 : _a.series) {
+        series = series.concat(result.data.series);
+      }
+    }
+    const combinedData = __spreadProps(__spreadValues({}, emptyPanelData), { series });
+    this._results.next({ origin: this, data: combinedData });
+    this.setStateHelper({ data: combinedData });
+  }
+  getResultsStream() {
+    return this._results;
+  }
+  cancelQuery() {
+    var _a;
+    (_a = this.querySub) == null ? void 0 : _a.unsubscribe();
+  }
+  setStateHelper(state) {
+    setBaseClassState(this, state);
+  }
+}
+class SceneDataLayerSet extends SceneDataLayerSetBase {
+  constructor(state) {
+    var _a, _b;
+    super({
+      name: (_a = state.name) != null ? _a : "Data layers",
+      layers: (_b = state.layers) != null ? _b : []
+    });
+    this.addActivationHandler(() => this._onActivate());
+  }
+  _onActivate() {
+    this._subs.add(
+      this.subscribeToState((newState, oldState) => {
+        var _a;
+        if (newState.layers !== oldState.layers) {
+          (_a = this.querySub) == null ? void 0 : _a.unsubscribe();
+          this.subscribeToAllLayers(newState.layers);
+        }
+      })
+    );
+    this.subscribeToAllLayers(this.state.layers);
+    return () => {
+      var _a;
+      (_a = this.querySub) == null ? void 0 : _a.unsubscribe();
+    };
+  }
+}
+SceneDataLayerSet.Component = ({ model }) => {
+  const { layers } = model.useState();
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, layers.map((layer) => /* @__PURE__ */ React.createElement(layer.Component, {
+    model: layer,
+    key: layer.state.key
+  })));
+};
+
+export { SceneDataLayerSet, SceneDataLayerSetBase };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"SceneDataLayerSet.js","sources":["../../../../src/querying/SceneDataLayerSet.tsx"],"sourcesContent":["import React from 'react';\nimport { DataFrame } from '@grafana/data';\nimport { Observable, ReplaySubject, Unsubscribable } from 'rxjs';\nimport { emptyPanelData } from '../core/SceneDataNode';\nimport { SceneObjectBase } from '../core/SceneObjectBase';\nimport {\n  SceneComponentProps,\n  SceneDataLayerProvider,\n  SceneDataLayerProviderState,\n  SceneDataProviderResult,\n} from '../core/types';\nimport { DataLayersMerger } from './DataLayersMerger';\nimport { setBaseClassState } from '../utils/utils';\n\nexport abstract class SceneDataLayerSetBase<T extends SceneDataLayerProviderState>\n  extends SceneObjectBase<T>\n  implements SceneDataLayerProvider\n{\n  /** Mark it as a data layer */\n  public isDataLayer: true = true;\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  private _dataLayersMerger = new DataLayersMerger();\n\n  protected subscribeToAllLayers(layers: SceneDataLayerProvider[]) {\n    if (layers.length > 0) {\n      this.querySub = this._dataLayersMerger.getMergedStream(layers).subscribe(this._onLayerUpdateReceived.bind(this));\n    } else {\n      this._results.next({ origin: this, data: emptyPanelData });\n      this.setStateHelper({ data: emptyPanelData });\n    }\n  }\n\n  private _onLayerUpdateReceived(results: Iterable<SceneDataProviderResult>) {\n    let series: DataFrame[] = [];\n\n    for (const result of results) {\n      if (result.data?.series) {\n        series = series.concat(result.data.series);\n      }\n    }\n\n    const combinedData = { ...emptyPanelData, series: series };\n\n    this._results.next({ origin: this, data: combinedData });\n    this.setStateHelper({ data: combinedData });\n  }\n\n  public getResultsStream(): Observable<SceneDataProviderResult> {\n    return this._results;\n  }\n\n  public cancelQuery() {\n    this.querySub?.unsubscribe();\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\nexport interface SceneDataLayersSetState extends SceneDataLayerProviderState {\n  layers: SceneDataLayerProvider[];\n}\n\nexport class SceneDataLayerSet\n  extends SceneDataLayerSetBase<SceneDataLayersSetState>\n  implements SceneDataLayerProvider\n{\n  public constructor(state: Partial<SceneDataLayersSetState>) {\n    super({\n      name: state.name ?? 'Data layers',\n      layers: state.layers ?? [],\n    });\n\n    this.addActivationHandler(() => this._onActivate());\n  }\n\n  private _onActivate() {\n    this._subs.add(\n      this.subscribeToState((newState, oldState) => {\n        if (newState.layers !== oldState.layers) {\n          this.querySub?.unsubscribe();\n          this.subscribeToAllLayers(newState.layers);\n        }\n      })\n    );\n\n    this.subscribeToAllLayers(this.state.layers);\n\n    return () => {\n      this.querySub?.unsubscribe();\n    };\n  }\n\n  public static Component = ({ model }: SceneComponentProps<SceneDataLayerSet>) => {\n    const { layers } = model.useState();\n\n    return (\n      <>\n        {layers.map((layer) => (\n          <layer.Component model={layer} key={layer.state.key} />\n        ))}\n      </>\n    );\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/src/querying/SceneDataTransformer.js

@@ -0,0 +1,178 @@
+import { DataTopic, transformDataFrame, LoadingState } from '@grafana/data';
+import { toDataQueryError } from '@grafana/runtime';
+import { ReplaySubject, forkJoin, map, catchError, of } from 'rxjs';
+import { sceneGraph } from '../core/sceneGraph/index.js';
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+import { VariableDependencyConfig } from '../variables/VariableDependencyConfig.js';
+import { SceneDataLayerSet } from './SceneDataLayerSet.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 SceneDataTransformer extends SceneObjectBase {
+  constructor(state) {
+    super(state);
+    this._results = new ReplaySubject(1);
+    this._variableDependency = new VariableDependencyConfig(
+      this,
+      {
+        statePaths: ["transformations"],
+        onReferencedVariableValueChanged: () => this.reprocessTransformations()
+      }
+    );
+    this.addActivationHandler(() => this.activationHandler());
+  }
+  activationHandler() {
+    const sourceData = this.getSourceData();
+    this._subs.add(sourceData.subscribeToState((state) => this.transform(state.data)));
+    if (sourceData.state.data) {
+      this.transform(sourceData.state.data);
+    }
+    return () => {
+      if (this._transformSub) {
+        this._transformSub.unsubscribe();
+      }
+    };
+  }
+  getSourceData() {
+    if (this.state.$data) {
+      if (this.state.$data instanceof SceneDataLayerSet) {
+        throw new Error("SceneDataLayerSet can not be used as data provider for SceneDataTransformer.");
+      }
+      return this.state.$data;
+    }
+    if (!this.parent || !this.parent.parent) {
+      throw new Error("SceneDataTransformer must either have $data set on it or have a parent.parent with $data");
+    }
+    return sceneGraph.getData(this.parent.parent);
+  }
+  setContainerWidth(width) {
+    if (this.state.$data && this.state.$data.setContainerWidth) {
+      this.state.$data.setContainerWidth(width);
+    }
+  }
+  isDataReadyToDisplay() {
+    const dataObject = this.getSourceData();
+    if (dataObject.isDataReadyToDisplay) {
+      return dataObject.isDataReadyToDisplay();
+    }
+    return true;
+  }
+  reprocessTransformations() {
+    this.transform(this.getSourceData().state.data, true);
+  }
+  cancelQuery() {
+    var _a, _b;
+    (_b = (_a = this.getSourceData()).cancelQuery) == null ? void 0 : _b.call(_a);
+  }
+  getResultsStream() {
+    return this._results;
+  }
+  clone(withState) {
+    const clone = super.clone(withState);
+    if (this._prevDataFromSource) {
+      clone["_prevDataFromSource"] = this._prevDataFromSource;
+    }
+    return clone;
+  }
+  haveAlreadyTransformedData(data) {
+    if (!this._prevDataFromSource) {
+      return false;
+    }
+    if (data === this._prevDataFromSource) {
+      return true;
+    }
+    const { series, annotations } = this._prevDataFromSource;
+    if (data.series === series && data.annotations === annotations) {
+      if (this.state.data && data.state !== this.state.data.state) {
+        this.setState({ data: __spreadProps(__spreadValues({}, this.state.data), { state: data.state }) });
+      }
+      return true;
+    }
+    return false;
+  }
+  transform(data, force = false) {
+    var _a;
+    if (this.state.transformations.length === 0 || !data) {
+      this._prevDataFromSource = data;
+      this.setState({ data });
+      if (data) {
+        this._results.next({ origin: this, data });
+      }
+      return;
+    }
+    if (!force && this.haveAlreadyTransformedData(data)) {
+      return;
+    }
+    const seriesTransformations = this.state.transformations.filter((transformation) => {
+      if ("options" in transformation || "topic" in transformation) {
+        return transformation.topic == null || transformation.topic === DataTopic.Series;
+      }
+      return true;
+    }).map((transformation) => "operator" in transformation ? transformation.operator : transformation);
+    const annotationsTransformations = this.state.transformations.filter((transformation) => {
+      if ("options" in transformation || "topic" in transformation) {
+        return transformation.topic === DataTopic.Annotations;
+      }
+      return false;
+    }).map((transformation) => "operator" in transformation ? transformation.operator : transformation);
+    if (this._transformSub) {
+      this._transformSub.unsubscribe();
+    }
+    const ctx = {
+      interpolate: (value) => {
+        var _a2;
+        return sceneGraph.interpolate(this, value, (_a2 = data.request) == null ? void 0 : _a2.scopedVars);
+      }
+    };
+    let streams = [transformDataFrame(seriesTransformations, data.series, ctx)];
+    if (data.annotations && data.annotations.length > 0 && annotationsTransformations.length > 0) {
+      streams.push(transformDataFrame(annotationsTransformations, (_a = data.annotations) != null ? _a : []));
+    }
+    this._transformSub = forkJoin(streams).pipe(
+      map((values) => {
+        const transformedSeries = values[0];
+        const transformedAnnotations = values[1];
+        return __spreadProps(__spreadValues({}, data), {
+          series: transformedSeries,
+          annotations: transformedAnnotations != null ? transformedAnnotations : data.annotations
+        });
+      }),
+      catchError((err) => {
+        var _a2;
+        console.error("Error transforming data: ", err);
+        const sourceErr = ((_a2 = this.getSourceData().state.data) == null ? void 0 : _a2.errors) || [];
+        const transformationError = toDataQueryError(err);
+        transformationError.message = `Error transforming data: ${transformationError.message}`;
+        const result = __spreadProps(__spreadValues({}, data), {
+          state: LoadingState.Error,
+          errors: [...sourceErr, transformationError]
+        });
+        return of(result);
+      })
+    ).subscribe((transformedData) => {
+      this.setState({ data: transformedData });
+      this._results.next({ origin: this, data: transformedData });
+      this._prevDataFromSource = data;
+    });
+  }
+}
+
+export { SceneDataTransformer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"SceneDataTransformer.js","sources":["../../../../src/querying/SceneDataTransformer.ts"],"sourcesContent":["import { DataTopic, DataTransformerConfig, LoadingState, PanelData, transformDataFrame } from '@grafana/data';\nimport { toDataQueryError } from '@grafana/runtime';\nimport { catchError, forkJoin, map, of, ReplaySubject, Unsubscribable } from 'rxjs';\nimport { sceneGraph } from '../core/sceneGraph';\nimport { SceneObjectBase } from '../core/SceneObjectBase';\nimport { CustomTransformerDefinition, SceneDataProvider, SceneDataProviderResult, SceneDataState } from '../core/types';\nimport { VariableDependencyConfig } from '../variables/VariableDependencyConfig';\nimport { SceneDataLayerSet } from './SceneDataLayerSet';\n\nexport interface SceneDataTransformerState extends SceneDataState {\n  /**\n   * Array of standard transformation configs and custom transform operators\n   */\n  transformations: Array<DataTransformerConfig | CustomTransformerDefinition>;\n}\n\n/**\n * You can use this as a $data object. It can either transform an inner $data DataProvider or if that is not set it will\n * subscribe to a DataProvider higher up in the scene graph and transform its data.\n *\n * The transformations array supports custom (runtime defined) transformation as well as declarative core transformations.\n * You can manually re-process the transformations by calling reprocessTransformations(). This is useful if you have\n * transformations that depend on other scene object states.\n */\nexport class SceneDataTransformer extends SceneObjectBase<SceneDataTransformerState> implements SceneDataProvider {\n  private _transformSub?: Unsubscribable;\n  private _results = new ReplaySubject<SceneDataProviderResult>(1);\n  private _prevDataFromSource?: PanelData;\n\n  /**\n   * Scan transformations for variable usage and re-process transforms when a variable values change\n   */\n  protected _variableDependency: VariableDependencyConfig<SceneDataTransformerState> = new VariableDependencyConfig(\n    this,\n    {\n      statePaths: ['transformations'],\n      onReferencedVariableValueChanged: () => this.reprocessTransformations(),\n    }\n  );\n\n  public constructor(state: SceneDataTransformerState) {\n    super(state);\n\n    this.addActivationHandler(() => this.activationHandler());\n  }\n\n  private activationHandler() {\n    const sourceData = this.getSourceData();\n\n    this._subs.add(sourceData.subscribeToState((state) => this.transform(state.data)));\n\n    if (sourceData.state.data) {\n      this.transform(sourceData.state.data);\n    }\n\n    return () => {\n      if (this._transformSub) {\n        this._transformSub.unsubscribe();\n      }\n    };\n  }\n\n  private getSourceData(): SceneDataProvider {\n    if (this.state.$data) {\n      if (this.state.$data instanceof SceneDataLayerSet) {\n        throw new Error('SceneDataLayerSet can not be used as data provider for SceneDataTransformer.');\n      }\n      return this.state.$data;\n    }\n\n    if (!this.parent || !this.parent.parent) {\n      throw new Error('SceneDataTransformer must either have $data set on it or have a parent.parent with $data');\n    }\n\n    return sceneGraph.getData(this.parent.parent);\n  }\n\n  public setContainerWidth(width: number) {\n    if (this.state.$data && this.state.$data.setContainerWidth) {\n      this.state.$data.setContainerWidth(width);\n    }\n  }\n\n  public isDataReadyToDisplay() {\n    const dataObject = this.getSourceData();\n    if (dataObject.isDataReadyToDisplay) {\n      return dataObject.isDataReadyToDisplay();\n    }\n\n    return true;\n  }\n\n  public reprocessTransformations() {\n    this.transform(this.getSourceData().state.data, true);\n  }\n\n  public cancelQuery() {\n    this.getSourceData().cancelQuery?.();\n  }\n\n  public getResultsStream() {\n    return this._results;\n  }\n\n  public clone(withState?: Partial<SceneDataTransformerState>) {\n    const clone = super.clone(withState);\n\n    if (this._prevDataFromSource) {\n      clone['_prevDataFromSource'] = this._prevDataFromSource;\n    }\n\n    return clone;\n  }\n\n  private haveAlreadyTransformedData(data: PanelData) {\n    if (!this._prevDataFromSource) {\n      return false;\n    }\n\n    if (data === this._prevDataFromSource) {\n      return true;\n    }\n\n    const { series, annotations } = this._prevDataFromSource;\n\n    if (data.series === series && data.annotations === annotations) {\n      if (this.state.data && data.state !== this.state.data.state) {\n        this.setState({ data: { ...this.state.data, state: data.state } });\n      }\n      return true;\n    }\n\n    return false;\n  }\n\n  private transform(data: PanelData | undefined, force = false) {\n    if (this.state.transformations.length === 0 || !data) {\n      this._prevDataFromSource = data;\n      this.setState({ data });\n\n      if (data) {\n        this._results.next({ origin: this, data });\n      }\n      return;\n    }\n\n    // Skip transform step if we have already transformed this data\n    if (!force && this.haveAlreadyTransformedData(data)) {\n      return;\n    }\n\n    const seriesTransformations = this.state.transformations\n      .filter((transformation) => {\n        if ('options' in transformation || 'topic' in transformation) {\n          return transformation.topic == null || transformation.topic === DataTopic.Series;\n        }\n\n        return true;\n      })\n      .map((transformation) => ('operator' in transformation ? transformation.operator : transformation));\n\n    const annotationsTransformations = this.state.transformations\n      .filter((transformation) => {\n        if ('options' in transformation || 'topic' in transformation) {\n          return transformation.topic === DataTopic.Annotations;\n        }\n\n        return false;\n      })\n      .map((transformation) => ('operator' in transformation ? transformation.operator : transformation));\n\n    if (this._transformSub) {\n      this._transformSub.unsubscribe();\n    }\n\n    const ctx = {\n      interpolate: (value: string) => {\n        return sceneGraph.interpolate(this, value, data.request?.scopedVars);\n      },\n    };\n\n    let streams = [transformDataFrame(seriesTransformations, data.series, ctx)];\n\n    if (data.annotations && data.annotations.length > 0 && annotationsTransformations.length > 0) {\n      streams.push(transformDataFrame(annotationsTransformations, data.annotations ?? []));\n    }\n\n    this._transformSub = forkJoin(streams)\n      .pipe(\n        map((values) => {\n          const transformedSeries = values[0];\n          const transformedAnnotations = values[1];\n\n          return {\n            ...data,\n            series: transformedSeries,\n            annotations: transformedAnnotations ?? data.annotations,\n          };\n        }),\n        catchError((err) => {\n          console.error('Error transforming data: ', err);\n          const sourceErr = this.getSourceData().state.data?.errors || [];\n\n          const transformationError = toDataQueryError(err);\n          transformationError.message = `Error transforming data: ${transformationError.message}`;\n\n          const result: PanelData = {\n            ...data,\n            state: LoadingState.Error,\n            // Combine transformation error with upstream errors\n            errors: [...sourceErr, transformationError],\n          };\n\n          return of(result);\n        })\n      )\n      .subscribe((transformedData) => {\n        this.setState({ data: transformedData });\n        this._results.next({ origin: this, data: transformedData });\n        this._prevDataFromSource = data;\n      });\n  }\n}\n"],"names":["_a"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBO,MAAM,6BAA6B,eAAwE,CAAA;AAAA,EAgBzG,YAAY,KAAkC,EAAA;AACnD,IAAA,KAAA,CAAM,KAAK,CAAA,CAAA;AAfb,IAAQ,IAAA,CAAA,QAAA,GAAW,IAAI,aAAA,CAAuC,CAAC,CAAA,CAAA;AAM/D,IAAA,IAAA,CAAU,sBAA2E,IAAI,wBAAA;AAAA,MACvF,IAAA;AAAA,MACA;AAAA,QACE,UAAA,EAAY,CAAC,iBAAiB,CAAA;AAAA,QAC9B,gCAAA,EAAkC,MAAM,IAAA,CAAK,wBAAyB,EAAA;AAAA,OACxE;AAAA,KACF,CAAA;AAKE,IAAA,IAAA,CAAK,oBAAqB,CAAA,MAAM,IAAK,CAAA,iBAAA,EAAmB,CAAA,CAAA;AAAA,GAC1D;AAAA,EAEQ,iBAAoB,GAAA;AAC1B,IAAM,MAAA,UAAA,GAAa,KAAK,aAAc,EAAA,CAAA;AAEtC,IAAK,IAAA,CAAA,KAAA,CAAM,GAAI,CAAA,UAAA,CAAW,gBAAiB,CAAA,CAAC,KAAU,KAAA,IAAA,CAAK,SAAU,CAAA,KAAA,CAAM,IAAI,CAAC,CAAC,CAAA,CAAA;AAEjF,IAAI,IAAA,UAAA,CAAW,MAAM,IAAM,EAAA;AACzB,MAAK,IAAA,CAAA,SAAA,CAAU,UAAW,CAAA,KAAA,CAAM,IAAI,CAAA,CAAA;AAAA,KACtC;AAEA,IAAA,OAAO,MAAM;AACX,MAAA,IAAI,KAAK,aAAe,EAAA;AACtB,QAAA,IAAA,CAAK,cAAc,WAAY,EAAA,CAAA;AAAA,OACjC;AAAA,KACF,CAAA;AAAA,GACF;AAAA,EAEQ,aAAmC,GAAA;AACzC,IAAI,IAAA,IAAA,CAAK,MAAM,KAAO,EAAA;AACpB,MAAI,IAAA,IAAA,CAAK,KAAM,CAAA,KAAA,YAAiB,iBAAmB,EAAA;AACjD,QAAM,MAAA,IAAI,MAAM,8EAA8E,CAAA,CAAA;AAAA,OAChG;AACA,MAAA,OAAO,KAAK,KAAM,CAAA,KAAA,CAAA;AAAA,KACpB;AAEA,IAAA,IAAI,CAAC,IAAK,CAAA,MAAA,IAAU,CAAC,IAAA,CAAK,OAAO,MAAQ,EAAA;AACvC,MAAM,MAAA,IAAI,MAAM,0FAA0F,CAAA,CAAA;AAAA,KAC5G;AAEA,IAAA,OAAO,UAAW,CAAA,OAAA,CAAQ,IAAK,CAAA,MAAA,CAAO,MAAM,CAAA,CAAA;AAAA,GAC9C;AAAA,EAEO,kBAAkB,KAAe,EAAA;AACtC,IAAA,IAAI,KAAK,KAAM,CAAA,KAAA,IAAS,IAAK,CAAA,KAAA,CAAM,MAAM,iBAAmB,EAAA;AAC1D,MAAK,IAAA,CAAA,KAAA,CAAM,KAAM,CAAA,iBAAA,CAAkB,KAAK,CAAA,CAAA;AAAA,KAC1C;AAAA,GACF;AAAA,EAEO,oBAAuB,GAAA;AAC5B,IAAM,MAAA,UAAA,GAAa,KAAK,aAAc,EAAA,CAAA;AACtC,IAAA,IAAI,WAAW,oBAAsB,EAAA;AACnC,MAAA,OAAO,WAAW,oBAAqB,EAAA,CAAA;AAAA,KACzC;AAEA,IAAO,OAAA,IAAA,CAAA;AAAA,GACT;AAAA,EAEO,wBAA2B,GAAA;AAChC,IAAA,IAAA,CAAK,UAAU,IAAK,CAAA,aAAA,EAAgB,CAAA,KAAA,CAAM,MAAM,IAAI,CAAA,CAAA;AAAA,GACtD;AAAA,EAEO,WAAc,GAAA;AAhGvB,IAAA,IAAA,EAAA,EAAA,EAAA,CAAA;AAiGI,IAAK,CAAA,EAAA,GAAA,CAAA,EAAA,GAAA,IAAA,CAAA,aAAA,IAAgB,WAArB,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAA,CAAA,EAAA,CAAA,CAAA;AAAA,GACF;AAAA,EAEO,gBAAmB,GAAA;AACxB,IAAA,OAAO,IAAK,CAAA,QAAA,CAAA;AAAA,GACd;AAAA,EAEO,MAAM,SAAgD,EAAA;AAC3D,IAAM,MAAA,KAAA,GAAQ,KAAM,CAAA,KAAA,CAAM,SAAS,CAAA,CAAA;AAEnC,IAAA,IAAI,KAAK,mBAAqB,EAAA;AAC5B,MAAA,KAAA,CAAM,yBAAyB,IAAK,CAAA,mBAAA,CAAA;AAAA,KACtC;AAEA,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAAA,EAEQ,2BAA2B,IAAiB,EAAA;AAClD,IAAI,IAAA,CAAC,KAAK,mBAAqB,EAAA;AAC7B,MAAO,OAAA,KAAA,CAAA;AAAA,KACT;AAEA,IAAI,IAAA,IAAA,KAAS,KAAK,mBAAqB,EAAA;AACrC,MAAO,OAAA,IAAA,CAAA;AAAA,KACT;AAEA,IAAA,MAAM,EAAE,MAAA,EAAQ,WAAY,EAAA,GAAI,IAAK,CAAA,mBAAA,CAAA;AAErC,IAAA,IAAI,IAAK,CAAA,MAAA,KAAW,MAAU,IAAA,IAAA,CAAK,gBAAgB,WAAa,EAAA;AAC9D,MAAI,IAAA,IAAA,CAAK,MAAM,IAAQ,IAAA,IAAA,CAAK,UAAU,IAAK,CAAA,KAAA,CAAM,KAAK,KAAO,EAAA;AAC3D,QAAA,IAAA,CAAK,QAAS,CAAA,EAAE,IAAM,EAAA,aAAA,CAAA,cAAA,CAAA,EAAA,EAAK,IAAK,CAAA,KAAA,CAAM,IAAhB,CAAA,EAAA,EAAsB,KAAO,EAAA,IAAA,CAAK,KAAM,EAAA,CAAA,EAAG,CAAA,CAAA;AAAA,OACnE;AACA,MAAO,OAAA,IAAA,CAAA;AAAA,KACT;AAEA,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAAA,EAEQ,SAAA,CAAU,IAA6B,EAAA,KAAA,GAAQ,KAAO,EAAA;AAvIhE,IAAA,IAAA,EAAA,CAAA;AAwII,IAAA,IAAI,KAAK,KAAM,CAAA,eAAA,CAAgB,MAAW,KAAA,CAAA,IAAK,CAAC,IAAM,EAAA;AACpD,MAAA,IAAA,CAAK,mBAAsB,GAAA,IAAA,CAAA;AAC3B,MAAK,IAAA,CAAA,QAAA,CAAS,EAAE,IAAA,EAAM,CAAA,CAAA;AAEtB,MAAA,IAAI,IAAM,EAAA;AACR,QAAA,IAAA,CAAK,SAAS,IAAK,CAAA,EAAE,MAAQ,EAAA,IAAA,EAAM,MAAM,CAAA,CAAA;AAAA,OAC3C;AACA,MAAA,OAAA;AAAA,KACF;AAGA,IAAA,IAAI,CAAC,KAAA,IAAS,IAAK,CAAA,0BAAA,CAA2B,IAAI,CAAG,EAAA;AACnD,MAAA,OAAA;AAAA,KACF;AAEA,IAAA,MAAM,wBAAwB,IAAK,CAAA,KAAA,CAAM,eACtC,CAAA,MAAA,CAAO,CAAC,cAAmB,KAAA;AAC1B,MAAI,IAAA,SAAA,IAAa,cAAkB,IAAA,OAAA,IAAW,cAAgB,EAAA;AAC5D,QAAA,OAAO,cAAe,CAAA,KAAA,IAAS,IAAQ,IAAA,cAAA,CAAe,UAAU,SAAU,CAAA,MAAA,CAAA;AAAA,OAC5E;AAEA,MAAO,OAAA,IAAA,CAAA;AAAA,KACR,EACA,GAAI,CAAA,CAAC,mBAAoB,UAAc,IAAA,cAAA,GAAiB,cAAe,CAAA,QAAA,GAAW,cAAe,CAAA,CAAA;AAEpG,IAAA,MAAM,6BAA6B,IAAK,CAAA,KAAA,CAAM,eAC3C,CAAA,MAAA,CAAO,CAAC,cAAmB,KAAA;AAC1B,MAAI,IAAA,SAAA,IAAa,cAAkB,IAAA,OAAA,IAAW,cAAgB,EAAA;AAC5D,QAAO,OAAA,cAAA,CAAe,UAAU,SAAU,CAAA,WAAA,CAAA;AAAA,OAC5C;AAEA,MAAO,OAAA,KAAA,CAAA;AAAA,KACR,EACA,GAAI,CAAA,CAAC,mBAAoB,UAAc,IAAA,cAAA,GAAiB,cAAe,CAAA,QAAA,GAAW,cAAe,CAAA,CAAA;AAEpG,IAAA,IAAI,KAAK,aAAe,EAAA;AACtB,MAAA,IAAA,CAAK,cAAc,WAAY,EAAA,CAAA;AAAA,KACjC;AAEA,IAAA,MAAM,GAAM,GAAA;AAAA,MACV,WAAA,EAAa,CAAC,KAAkB,KAAA;AAhLtC,QAAAA,IAAAA,GAAAA,CAAAA;AAiLQ,QAAO,OAAA,UAAA,CAAW,YAAY,IAAM,EAAA,KAAA,EAAA,CAAOA,MAAA,IAAK,CAAA,OAAA,KAAL,IAAAA,GAAAA,KAAAA,CAAAA,GAAAA,GAAAA,CAAc,UAAU,CAAA,CAAA;AAAA,OACrE;AAAA,KACF,CAAA;AAEA,IAAA,IAAI,UAAU,CAAC,kBAAA,CAAmB,uBAAuB,IAAK,CAAA,MAAA,EAAQ,GAAG,CAAC,CAAA,CAAA;AAE1E,IAAI,IAAA,IAAA,CAAK,eAAe,IAAK,CAAA,WAAA,CAAY,SAAS,CAAK,IAAA,0BAAA,CAA2B,SAAS,CAAG,EAAA;AAC5F,MAAQ,OAAA,CAAA,IAAA,CAAK,mBAAmB,0BAA4B,EAAA,CAAA,EAAA,GAAA,IAAA,CAAK,gBAAL,IAAoB,GAAA,EAAA,GAAA,EAAE,CAAC,CAAA,CAAA;AAAA,KACrF;AAEA,IAAK,IAAA,CAAA,aAAA,GAAgB,QAAS,CAAA,OAAO,CAClC,CAAA,IAAA;AAAA,MACC,GAAA,CAAI,CAAC,MAAW,KAAA;AACd,QAAA,MAAM,oBAAoB,MAAO,CAAA,CAAA,CAAA,CAAA;AACjC,QAAA,MAAM,yBAAyB,MAAO,CAAA,CAAA,CAAA,CAAA;AAEtC,QAAA,OAAO,iCACF,IADE,CAAA,EAAA;AAAA,UAEL,MAAQ,EAAA,iBAAA;AAAA,UACR,WAAA,EAAa,0DAA0B,IAAK,CAAA,WAAA;AAAA,SAC9C,CAAA,CAAA;AAAA,OACD,CAAA;AAAA,MACD,UAAA,CAAW,CAAC,GAAQ,KAAA;AAvM5B,QAAAA,IAAAA,GAAAA,CAAAA;AAwMU,QAAQ,OAAA,CAAA,KAAA,CAAM,6BAA6B,GAAG,CAAA,CAAA;AAC9C,QAAM,MAAA,SAAA,GAAA,CAAA,CAAYA,GAAA,GAAA,IAAA,CAAK,aAAc,EAAA,CAAE,MAAM,IAA3B,KAAA,IAAA,GAAA,KAAA,CAAA,GAAAA,GAAiC,CAAA,MAAA,KAAU,EAAC,CAAA;AAE9D,QAAM,MAAA,mBAAA,GAAsB,iBAAiB,GAAG,CAAA,CAAA;AAChD,QAAoB,mBAAA,CAAA,OAAA,GAAU,4BAA4B,mBAAoB,CAAA,OAAA,CAAA,CAAA,CAAA;AAE9E,QAAM,MAAA,MAAA,GAAoB,iCACrB,IADqB,CAAA,EAAA;AAAA,UAExB,OAAO,YAAa,CAAA,KAAA;AAAA,UAEpB,MAAQ,EAAA,CAAC,GAAG,SAAA,EAAW,mBAAmB,CAAA;AAAA,SAC5C,CAAA,CAAA;AAEA,QAAA,OAAO,GAAG,MAAM,CAAA,CAAA;AAAA,OACjB,CAAA;AAAA,KACH,CACC,SAAU,CAAA,CAAC,eAAoB,KAAA;AAC9B,MAAA,IAAA,CAAK,QAAS,CAAA,EAAE,IAAM,EAAA,eAAA,EAAiB,CAAA,CAAA;AACvC,MAAA,IAAA,CAAK,SAAS,IAAK,CAAA,EAAE,QAAQ,IAAM,EAAA,IAAA,EAAM,iBAAiB,CAAA,CAAA;AAC1D,MAAA,IAAA,CAAK,mBAAsB,GAAA,IAAA,CAAA;AAAA,KAC5B,CAAA,CAAA;AAAA,GACL;AACF;;;;"}