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

package/dist/esm/src/core/SceneTimeRangeTransformerBase.js

@@ -0,0 +1,35 @@
+import { sceneGraph } from './sceneGraph/index.js';
+import { SceneObjectBase } from './SceneObjectBase.js';
+
+class SceneTimeRangeTransformerBase extends SceneObjectBase {
+  constructor(state) {
+    super(state);
+    this._activationHandler = () => {
+      const ancestorTimeRange = this.getAncestorTimeRange();
+      this.ancestorTimeRangeChanged(ancestorTimeRange.state);
+      this._subs.add(ancestorTimeRange.subscribeToState((s) => this.ancestorTimeRangeChanged(s)));
+    };
+    this.addActivationHandler(this._activationHandler);
+  }
+  getAncestorTimeRange() {
+    if (!this.parent || !this.parent.parent) {
+      throw new Error(typeof this + " must be used within $timeRange scope");
+    }
+    return sceneGraph.getTimeRange(this.parent.parent);
+  }
+  getTimeZone() {
+    return this.getAncestorTimeRange().getTimeZone();
+  }
+  onTimeRangeChange(timeRange) {
+    this.getAncestorTimeRange().onTimeRangeChange(timeRange);
+  }
+  onTimeZoneChange(timeZone) {
+    this.getAncestorTimeRange().onTimeZoneChange(timeZone);
+  }
+  onRefresh() {
+    this.getAncestorTimeRange().onRefresh();
+  }
+}
+
+export { SceneTimeRangeTransformerBase };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2NlbmVUaW1lUmFuZ2VUcmFuc2Zvcm1lckJhc2UuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb3JlL1NjZW5lVGltZVJhbmdlVHJhbnNmb3JtZXJCYXNlLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUaW1lUmFuZ2UgfSBmcm9tICdAZ3JhZmFuYS9kYXRhJztcbmltcG9ydCB7IFRpbWVab25lIH0gZnJvbSAnQGdyYWZhbmEvc2NoZW1hJztcbmltcG9ydCB7IHNjZW5lR3JhcGggfSBmcm9tICcuL3NjZW5lR3JhcGgnO1xuaW1wb3J0IHsgU2NlbmVPYmplY3RCYXNlIH0gZnJvbSAnLi9TY2VuZU9iamVjdEJhc2UnO1xuaW1wb3J0IHsgU2NlbmVUaW1lUmFuZ2VMaWtlLCBTY2VuZVRpbWVSYW5nZVN0YXRlIH0gZnJvbSAnLi90eXBlcyc7XG5cbi8qKlxuICogQGludGVybmFsXG4gKiBVc2VkIGJ5IFNjZW5lVGltZVpvbmVPdmVycmlkZSBhbmQgbWFpbiByZXBvIFBhbmVsVGltZVJhbmdlLlxuICogTm90IHJlY29tbWVuZWQgdG8gYmUgdXNlZCBieSBwbHVnaW5zIGRpcmVjdGx5LlxuICovXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgU2NlbmVUaW1lUmFuZ2VUcmFuc2Zvcm1lckJhc2U8VCBleHRlbmRzIFNjZW5lVGltZVJhbmdlU3RhdGU+XG4gIGV4dGVuZHMgU2NlbmVPYmplY3RCYXNlPFQ+XG4gIGltcGxlbWVudHMgU2NlbmVUaW1lUmFuZ2VMaWtlXG57XG4gIHB1YmxpYyBjb25zdHJ1Y3RvcihzdGF0ZTogVCkge1xuICAgIHN1cGVyKHN0YXRlKTtcblxuICAgIHRoaXMuYWRkQWN0aXZhdGlvbkhhbmRsZXIodGhpcy5fYWN0aXZhdGlvbkhhbmRsZXIpO1xuICB9XG5cbiAgcHJvdGVjdGVkIGdldEFuY2VzdG9yVGltZVJhbmdlKCkge1xuICAgIGlmICghdGhpcy5wYXJlbnQgfHwgIXRoaXMucGFyZW50LnBhcmVudCkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKHR5cGVvZiB0aGlzICsgJyBtdXN0IGJlIHVzZWQgd2l0aGluICR0aW1lUmFuZ2Ugc2NvcGUnKTtcbiAgICB9XG5cbiAgICByZXR1cm4gc2NlbmVHcmFwaC5nZXRUaW1lUmFuZ2UodGhpcy5wYXJlbnQucGFyZW50KTtcbiAgfVxuXG4gIHByaXZhdGUgX2FjdGl2YXRpb25IYW5kbGVyID0gKCkgPT4ge1xuICAgIGNvbnN0IGFuY2VzdG9yVGltZVJhbmdlID0gdGhpcy5nZXRBbmNlc3RvclRpbWVSYW5nZSgpO1xuXG4gICAgdGhpcy5hbmNlc3RvclRpbWVSYW5nZUNoYW5nZWQoYW5jZXN0b3JUaW1lUmFuZ2Uuc3RhdGUpO1xuXG4gICAgdGhpcy5fc3Vicy5hZGQoYW5jZXN0b3JUaW1lUmFuZ2Uuc3Vic2NyaWJlVG9TdGF0ZSgocykgPT4gdGhpcy5hbmNlc3RvclRpbWVSYW5nZUNoYW5nZWQocykpKTtcbiAgfTtcblxuICBwcm90ZWN0ZWQgYWJzdHJhY3QgYW5jZXN0b3JUaW1lUmFuZ2VDaGFuZ2VkKHRpbWVSYW5nZTogU2NlbmVUaW1lUmFuZ2VTdGF0ZSk6IHZvaWQ7XG5cbiAgcHVibGljIGdldFRpbWVab25lKCk6IFRpbWVab25lIHtcbiAgICByZXR1cm4gdGhpcy5nZXRBbmNlc3RvclRpbWVSYW5nZSgpLmdldFRpbWVab25lKCk7XG4gIH1cblxuICBwdWJsaWMgb25UaW1lUmFuZ2VDaGFuZ2UodGltZVJhbmdlOiBUaW1lUmFuZ2UpOiB2b2lkIHtcbiAgICB0aGlzLmdldEFuY2VzdG9yVGltZVJhbmdlKCkub25UaW1lUmFuZ2VDaGFuZ2UodGltZVJhbmdlKTtcbiAgfVxuXG4gIHB1YmxpYyBvblRpbWVab25lQ2hhbmdlKHRpbWVab25lOiBzdHJpbmcpOiB2b2lkIHtcbiAgICB0aGlzLmdldEFuY2VzdG9yVGltZVJhbmdlKCkub25UaW1lWm9uZUNoYW5nZSh0aW1lWm9uZSk7XG4gIH1cblxuICBwdWJsaWMgb25SZWZyZXNoKCk6IHZvaWQge1xuICAgIHRoaXMuZ2V0QW5jZXN0b3JUaW1lUmFuZ2UoKS5vblJlZnJlc2goKTtcbiAgfVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVdPLE1BQWUsc0NBQ1osZUFFVixDQUFBO0FBQUEsRUFDUyxZQUFZLEtBQVUsRUFBQTtBQUMzQixJQUFBLEtBQUEsQ0FBTSxLQUFLLENBQUEsQ0FBQTtBQWFiLElBQUEsSUFBQSxDQUFRLHFCQUFxQixNQUFNO0FBQ2pDLE1BQU0sTUFBQSxpQkFBQSxHQUFvQixLQUFLLG9CQUFxQixFQUFBLENBQUE7QUFFcEQsTUFBSyxJQUFBLENBQUEsd0JBQUEsQ0FBeUIsa0JBQWtCLEtBQUssQ0FBQSxDQUFBO0FBRXJELE1BQUssSUFBQSxDQUFBLEtBQUEsQ0FBTSxHQUFJLENBQUEsaUJBQUEsQ0FBa0IsZ0JBQWlCLENBQUEsQ0FBQyxNQUFNLElBQUssQ0FBQSx3QkFBQSxDQUF5QixDQUFDLENBQUMsQ0FBQyxDQUFBLENBQUE7QUFBQSxLQUM1RixDQUFBO0FBakJFLElBQUssSUFBQSxDQUFBLG9CQUFBLENBQXFCLEtBQUssa0JBQWtCLENBQUEsQ0FBQTtBQUFBLEdBQ25EO0FBQUEsRUFFVSxvQkFBdUIsR0FBQTtBQUMvQixJQUFBLElBQUksQ0FBQyxJQUFLLENBQUEsTUFBQSxJQUFVLENBQUMsSUFBQSxDQUFLLE9BQU8sTUFBUSxFQUFBO0FBQ3ZDLE1BQUEsTUFBTSxJQUFJLEtBQUEsQ0FBTSxPQUFPLElBQUEsR0FBTyx1Q0FBdUMsQ0FBQSxDQUFBO0FBQUEsS0FDdkU7QUFFQSxJQUFBLE9BQU8sVUFBVyxDQUFBLFlBQUEsQ0FBYSxJQUFLLENBQUEsTUFBQSxDQUFPLE1BQU0sQ0FBQSxDQUFBO0FBQUEsR0FDbkQ7QUFBQSxFQVlPLFdBQXdCLEdBQUE7QUFDN0IsSUFBTyxPQUFBLElBQUEsQ0FBSyxvQkFBcUIsRUFBQSxDQUFFLFdBQVksRUFBQSxDQUFBO0FBQUEsR0FDakQ7QUFBQSxFQUVPLGtCQUFrQixTQUE0QixFQUFBO0FBQ25ELElBQUssSUFBQSxDQUFBLG9CQUFBLEVBQXVCLENBQUEsaUJBQUEsQ0FBa0IsU0FBUyxDQUFBLENBQUE7QUFBQSxHQUN6RDtBQUFBLEVBRU8saUJBQWlCLFFBQXdCLEVBQUE7QUFDOUMsSUFBSyxJQUFBLENBQUEsb0JBQUEsRUFBdUIsQ0FBQSxnQkFBQSxDQUFpQixRQUFRLENBQUEsQ0FBQTtBQUFBLEdBQ3ZEO0FBQUEsRUFFTyxTQUFrQixHQUFBO0FBQ3ZCLElBQUssSUFBQSxDQUFBLG9CQUFBLEdBQXVCLFNBQVUsRUFBQSxDQUFBO0FBQUEsR0FDeEM7QUFDRjs7OzsifQ==

package/dist/esm/src/core/SceneTimeZoneOverride.js

@@ -0,0 +1,63 @@
+import { SceneTimeRangeTransformerBase } from './SceneTimeRangeTransformerBase.js';
+import { getDefaultTimeRange } from '@grafana/data';
+import { evaluateTimeRange } from '../utils/evaluateTimeRange.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 SceneTimeZoneOverride extends SceneTimeRangeTransformerBase {
+  constructor(state) {
+    super(__spreadProps(__spreadValues({}, state), {
+      timeZone: state.timeZone,
+      from: "now-6h",
+      to: "now",
+      value: getDefaultTimeRange()
+    }));
+  }
+  ancestorTimeRangeChanged(timeRange) {
+    this.setState(__spreadProps(__spreadValues({}, timeRange), {
+      timeZone: this.state.timeZone,
+      value: evaluateTimeRange(
+        timeRange.from,
+        timeRange.to,
+        this.state.timeZone,
+        timeRange.fiscalYearStartMonth,
+        timeRange.UNSAFE_nowDelay
+      )
+    }));
+  }
+  getTimeZone() {
+    return this.state.timeZone;
+  }
+  onTimeZoneChange(timeZone) {
+    this.setState({
+      timeZone,
+      value: evaluateTimeRange(
+        this.state.from,
+        this.state.to,
+        this.state.timeZone,
+        this.getAncestorTimeRange().state.fiscalYearStartMonth,
+        this.state.UNSAFE_nowDelay
+      )
+    });
+  }
+}
+
+export { SceneTimeZoneOverride };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/core/events.js

@@ -0,0 +1,11 @@
+import { BusEventWithPayload } from '@grafana/data';
+
+class SceneObjectStateChangedEvent extends BusEventWithPayload {
+}
+SceneObjectStateChangedEvent.type = "scene-object-state-change";
+class UserActionEvent extends BusEventWithPayload {
+}
+UserActionEvent.type = "scene-object-user-action";
+
+export { SceneObjectStateChangedEvent, UserActionEvent };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRzLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29yZS9ldmVudHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQnVzRXZlbnRXaXRoUGF5bG9hZCB9IGZyb20gJ0BncmFmYW5hL2RhdGEnO1xuXG5pbXBvcnQgeyBTY2VuZU9iamVjdCwgU2NlbmVPYmplY3RTdGF0ZSB9IGZyb20gJy4vdHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFNjZW5lT2JqZWN0U3RhdGVDaGFuZ2VkUGF5bG9hZDxUU3RhdGUgZXh0ZW5kcyBTY2VuZU9iamVjdFN0YXRlID0gU2NlbmVPYmplY3RTdGF0ZT4ge1xuICBwcmV2U3RhdGU6IFRTdGF0ZTtcbiAgbmV3U3RhdGU6IFRTdGF0ZTtcbiAgcGFydGlhbFVwZGF0ZTogUGFydGlhbDxUU3RhdGU+O1xuICBjaGFuZ2VkT2JqZWN0OiBTY2VuZU9iamVjdDxUU3RhdGU+O1xufVxuXG5leHBvcnQgY2xhc3MgU2NlbmVPYmplY3RTdGF0ZUNoYW5nZWRFdmVudCBleHRlbmRzIEJ1c0V2ZW50V2l0aFBheWxvYWQ8U2NlbmVPYmplY3RTdGF0ZUNoYW5nZWRQYXlsb2FkPiB7XG4gIHB1YmxpYyBzdGF0aWMgcmVhZG9ubHkgdHlwZSA9ICdzY2VuZS1vYmplY3Qtc3RhdGUtY2hhbmdlJztcbn1cblxudHlwZSBVc2VyQWN0aW9uRXZlbnRUeXBlID1cbiAgfCAncGFuZWwtZGVzY3JpcHRpb24tc2hvd24nXG4gIHwgJ3BhbmVsLXN0YXR1cy1tZXNzYWdlLWNsaWNrZWQnXG4gIHwgJ3BhbmVsLWNhbmNlbC1xdWVyeS1jbGlja2VkJ1xuICB8ICdwYW5lbC1tZW51LXNob3duJztcblxuaW50ZXJmYWNlIFVzZXJBY3Rpb25FdmVudFBheWxvYWQge1xuICBvcmlnaW46IFNjZW5lT2JqZWN0O1xuICBpbnRlcmFjdGlvbjogVXNlckFjdGlvbkV2ZW50VHlwZTtcbn1cbmV4cG9ydCBjbGFzcyBVc2VyQWN0aW9uRXZlbnQgZXh0ZW5kcyBCdXNFdmVudFdpdGhQYXlsb2FkPFVzZXJBY3Rpb25FdmVudFBheWxvYWQ+IHtcbiAgcHVibGljIHN0YXRpYyByZWFkb25seSB0eXBlID0gJ3NjZW5lLW9iamVjdC11c2VyLWFjdGlvbic7XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFXTyxNQUFNLHFDQUFxQyxtQkFBb0QsQ0FBQTtBQUV0RyxDQUFBO0FBRmEsNEJBQUEsQ0FDWSxJQUFPLEdBQUEsMkJBQUEsQ0FBQTtBQWF6QixNQUFNLHdCQUF3QixtQkFBNEMsQ0FBQTtBQUVqRixDQUFBO0FBRmEsZUFBQSxDQUNZLElBQU8sR0FBQSwwQkFBQTs7OzsifQ==

package/dist/esm/src/core/sceneGraph/getTimeRange.js

@@ -0,0 +1,10 @@
+import { DefaultTimeRange } from '../../variables/interpolation/defaults.js';
+import { getClosest } from './utils.js';
+
+function getTimeRange(sceneObject) {
+  var _a;
+  return (_a = getClosest(sceneObject, (s) => s.state.$timeRange)) != null ? _a : DefaultTimeRange;
+}
+
+export { getTimeRange };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0VGltZVJhbmdlLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvY29yZS9zY2VuZUdyYXBoL2dldFRpbWVSYW5nZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEZWZhdWx0VGltZVJhbmdlIH0gZnJvbSAnLi4vLi4vdmFyaWFibGVzL2ludGVycG9sYXRpb24vZGVmYXVsdHMnO1xuaW1wb3J0IHsgU2NlbmVPYmplY3QsIFNjZW5lVGltZVJhbmdlTGlrZSB9IGZyb20gJy4uL3R5cGVzJztcbmltcG9ydCB7IGdldENsb3Nlc3QgfSBmcm9tICcuL3V0aWxzJztcblxuLyoqXG4gKiBXaWxsIHdhbGsgdXAgdGhlIHNjZW5lIG9iamVjdCBncmFwaCB0byB0aGUgY2xvc2VzdCAkdGltZVJhbmdlIHNjZW5lIG9iamVjdFxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0VGltZVJhbmdlKHNjZW5lT2JqZWN0OiBTY2VuZU9iamVjdCk6IFNjZW5lVGltZVJhbmdlTGlrZSB7XG4gIHJldHVybiBnZXRDbG9zZXN0KHNjZW5lT2JqZWN0LCAocykgPT4gcy5zdGF0ZS4kdGltZVJhbmdlKSA/PyBEZWZhdWx0VGltZVJhbmdlO1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQU9PLFNBQVMsYUFBYSxXQUE4QyxFQUFBO0FBUDNFLEVBQUEsSUFBQSxFQUFBLENBQUE7QUFRRSxFQUFPLE9BQUEsQ0FBQSxFQUFBLEdBQUEsVUFBQSxDQUFXLGFBQWEsQ0FBQyxDQUFBLEtBQU0sRUFBRSxLQUFNLENBQUEsVUFBVSxNQUFqRCxJQUFzRCxHQUFBLEVBQUEsR0FBQSxnQkFBQSxDQUFBO0FBQy9EOzs7OyJ9

package/dist/esm/src/core/sceneGraph/index.js

@@ -0,0 +1,25 @@
+import { lookupVariable } from '../../variables/lookupVariable.js';
+import { getTimeRange } from './getTimeRange.js';
+import { getVariables, getData, getLayout, getDataLayers, interpolate, hasVariableDependencyInLoadingState, findByKey, findByKeyAndType, findObject, findAllObjects, getAncestor, findDescendents, getQueryController, getUrlSyncManager } from './sceneGraph.js';
+
+const sceneGraph = {
+  getVariables,
+  getData,
+  getTimeRange,
+  getLayout,
+  getDataLayers,
+  interpolate,
+  lookupVariable,
+  hasVariableDependencyInLoadingState,
+  findByKey,
+  findByKeyAndType,
+  findObject,
+  findAllObjects,
+  getAncestor,
+  findDescendents,
+  getQueryController,
+  getUrlSyncManager
+};
+
+export { sceneGraph };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9jb3JlL3NjZW5lR3JhcGgvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbG9va3VwVmFyaWFibGUgfSBmcm9tICcuLi8uLi92YXJpYWJsZXMvbG9va3VwVmFyaWFibGUnO1xuaW1wb3J0IHsgZ2V0VGltZVJhbmdlIH0gZnJvbSAnLi9nZXRUaW1lUmFuZ2UnO1xuaW1wb3J0IHtcbiAgZmluZEJ5S2V5LFxuICBmaW5kQnlLZXlBbmRUeXBlLFxuICBmaW5kT2JqZWN0LFxuICBmaW5kQWxsT2JqZWN0cyxcbiAgZ2V0RGF0YSxcbiAgZ2V0TGF5b3V0LFxuICBnZXRWYXJpYWJsZXMsXG4gIGdldERhdGFMYXllcnMsXG4gIGhhc1ZhcmlhYmxlRGVwZW5kZW5jeUluTG9hZGluZ1N0YXRlLFxuICBpbnRlcnBvbGF0ZSxcbiAgZ2V0QW5jZXN0b3IsXG4gIGZpbmREZXNjZW5kZW50cyxcbiAgZ2V0UXVlcnlDb250cm9sbGVyLFxuICBnZXRVcmxTeW5jTWFuYWdlcixcbn0gZnJvbSAnLi9zY2VuZUdyYXBoJztcblxuZXhwb3J0IGNvbnN0IHNjZW5lR3JhcGggPSB7XG4gIGdldFZhcmlhYmxlcyxcbiAgZ2V0RGF0YSxcbiAgZ2V0VGltZVJhbmdlLFxuICBnZXRMYXlvdXQsXG4gIGdldERhdGFMYXllcnMsXG4gIGludGVycG9sYXRlLFxuICBsb29rdXBWYXJpYWJsZSxcbiAgaGFzVmFyaWFibGVEZXBlbmRlbmN5SW5Mb2FkaW5nU3RhdGUsXG4gIGZpbmRCeUtleSxcbiAgZmluZEJ5S2V5QW5kVHlwZSxcbiAgZmluZE9iamVjdCxcbiAgZmluZEFsbE9iamVjdHMsXG4gIGdldEFuY2VzdG9yLFxuICBmaW5kRGVzY2VuZGVudHMsXG4gIGdldFF1ZXJ5Q29udHJvbGxlcixcbiAgZ2V0VXJsU3luY01hbmFnZXIsXG59O1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFtQk8sTUFBTSxVQUFhLEdBQUE7QUFBQSxFQUN4QixZQUFBO0FBQUEsRUFDQSxPQUFBO0FBQUEsRUFDQSxZQUFBO0FBQUEsRUFDQSxTQUFBO0FBQUEsRUFDQSxhQUFBO0FBQUEsRUFDQSxXQUFBO0FBQUEsRUFDQSxjQUFBO0FBQUEsRUFDQSxtQ0FBQTtBQUFBLEVBQ0EsU0FBQTtBQUFBLEVBQ0EsZ0JBQUE7QUFBQSxFQUNBLFVBQUE7QUFBQSxFQUNBLGNBQUE7QUFBQSxFQUNBLFdBQUE7QUFBQSxFQUNBLGVBQUE7QUFBQSxFQUNBLGtCQUFBO0FBQUEsRUFDQSxpQkFBQTtBQUNGOzs7OyJ9

package/dist/esm/src/core/sceneGraph/sceneGraph.js

@@ -0,0 +1,178 @@
+import { EmptyDataNode, EmptyVariableSet } from '../../variables/interpolation/defaults.js';
+import { sceneInterpolator } from '../../variables/interpolation/sceneInterpolator.js';
+import { isDataLayer } from '../types.js';
+import { lookupVariable } from '../../variables/lookupVariable.js';
+import { getClosest } from './utils.js';
+import { isQueryController } from '../../behaviors/SceneQueryController.js';
+import { QueryVariable } from '../../variables/variants/query/QueryVariable.js';
+
+function getVariables(sceneObject) {
+  var _a;
+  return (_a = getClosest(sceneObject, (s) => s.state.$variables)) != null ? _a : EmptyVariableSet;
+}
+function getData(sceneObject) {
+  var _a;
+  return (_a = getClosest(sceneObject, (s) => s.state.$data)) != null ? _a : EmptyDataNode;
+}
+function isSceneLayout(s) {
+  return "isDraggable" in s;
+}
+function getLayout(scene) {
+  const parent = getClosest(scene, (s) => isSceneLayout(s) ? s : void 0);
+  if (parent) {
+    return parent;
+  }
+  return null;
+}
+function interpolate(sceneObject, value, scopedVars, format, interpolations) {
+  if (value === "" || value == null) {
+    return "";
+  }
+  return sceneInterpolator(sceneObject, value, scopedVars, format, interpolations);
+}
+function hasVariableDependencyInLoadingState(sceneObject) {
+  if (!sceneObject.variableDependency) {
+    return false;
+  }
+  for (const name of sceneObject.variableDependency.getNames()) {
+    if (sceneObject instanceof QueryVariable && sceneObject.state.name === name) {
+      console.warn("Query variable is referencing itself");
+      continue;
+    }
+    const variable = lookupVariable(name, sceneObject);
+    if (!variable) {
+      continue;
+    }
+    const set = variable.parent;
+    if (set.isVariableLoadingOrWaitingToUpdate(variable)) {
+      return true;
+    }
+  }
+  return false;
+}
+function findObjectInternal(scene, check, alreadySearchedChild, shouldSearchUp) {
+  if (check(scene)) {
+    return scene;
+  }
+  let found = null;
+  scene.forEachChild((child) => {
+    if (child === alreadySearchedChild) {
+      return;
+    }
+    let maybe = findObjectInternal(child, check);
+    if (maybe) {
+      found = maybe;
+    }
+  });
+  if (found) {
+    return found;
+  }
+  if (shouldSearchUp && scene.parent) {
+    return findObjectInternal(scene.parent, check, scene, true);
+  }
+  return null;
+}
+function findByKey(sceneObject, key) {
+  const found = findObject(sceneObject, (sceneToCheck) => {
+    return sceneToCheck.state.key === key;
+  });
+  if (!found) {
+    throw new Error("Unable to find scene with key " + key);
+  }
+  return found;
+}
+function findByKeyAndType(sceneObject, key, targetType) {
+  const found = findObject(sceneObject, (sceneToCheck) => {
+    return sceneToCheck.state.key === key;
+  });
+  if (!found) {
+    throw new Error("Unable to find scene with key " + key);
+  }
+  if (!(found instanceof targetType)) {
+    throw new Error(`Found scene object with key ${key} does not match type ${targetType.name}`);
+  }
+  return found;
+}
+function findObject(scene, check) {
+  return findObjectInternal(scene, check, void 0, true);
+}
+function findAllObjects(scene, check) {
+  const found = [];
+  scene.forEachChild((child) => {
+    if (check(child)) {
+      found.push(child);
+    }
+    found.push(...findAllObjects(child, check));
+  });
+  return found;
+}
+function getDataLayers(sceneObject, localOnly = false) {
+  let currentLevel = sceneObject;
+  let collected = [];
+  while (currentLevel) {
+    const dataProvider = currentLevel.state.$data;
+    if (!dataProvider) {
+      currentLevel = currentLevel.parent;
+      continue;
+    }
+    if (isDataLayer(dataProvider)) {
+      collected = collected.concat(dataProvider);
+    } else {
+      if (dataProvider.state.$data && isDataLayer(dataProvider.state.$data)) {
+        collected = collected.concat(dataProvider.state.$data);
+      }
+    }
+    if (localOnly && collected.length > 0) {
+      break;
+    }
+    currentLevel = currentLevel.parent;
+  }
+  return collected;
+}
+function getAncestor(sceneObject, ancestorType) {
+  let parent = sceneObject;
+  while (parent) {
+    if (parent instanceof ancestorType) {
+      return parent;
+    }
+    parent = parent.parent;
+  }
+  if (!parent) {
+    throw new Error("Unable to find parent of type " + ancestorType.name);
+  }
+  return parent;
+}
+function findDescendents(scene, descendentType) {
+  function isDescendentType(scene2) {
+    return scene2 instanceof descendentType;
+  }
+  const targetScenes = findAllObjects(scene, isDescendentType);
+  return targetScenes.filter(isDescendentType);
+}
+function getQueryController(sceneObject) {
+  let parent = sceneObject;
+  while (parent) {
+    if (parent.state.$behaviors) {
+      for (const behavior of parent.state.$behaviors) {
+        if (isQueryController(behavior)) {
+          return behavior;
+        }
+      }
+    }
+    parent = parent.parent;
+  }
+  return void 0;
+}
+function getUrlSyncManager(sceneObject) {
+  let parent = sceneObject;
+  while (parent) {
+    if ("urlSyncManager" in parent.state) {
+      return parent.state.urlSyncManager;
+    }
+    parent = parent.parent;
+  }
+  return void 0;
+}
+
+export { findAllObjects, findByKey, findByKeyAndType, findDescendents, findObject, getAncestor, getData, getDataLayers, getLayout, getQueryController, getUrlSyncManager, getVariables, hasVariableDependencyInLoadingState, interpolate };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sceneGraph.js","sources":["../../../../../src/core/sceneGraph/sceneGraph.ts"],"sourcesContent":["import { ScopedVars } from '@grafana/data';\nimport { EmptyDataNode, EmptyVariableSet } from '../../variables/interpolation/defaults';\n\nimport { sceneInterpolator } from '../../variables/interpolation/sceneInterpolator';\nimport { VariableCustomFormatterFn, SceneVariables } from '../../variables/types';\n\nimport { isDataLayer, SceneDataLayerProvider, SceneDataProvider, SceneLayout, SceneObject } from '../types';\nimport { lookupVariable } from '../../variables/lookupVariable';\nimport { getClosest } from './utils';\nimport { SceneQueryControllerLike, isQueryController } from '../../behaviors/SceneQueryController';\nimport { VariableInterpolation } from '@grafana/runtime';\nimport { QueryVariable } from '../../variables/variants/query/QueryVariable';\nimport { UrlSyncManagerLike } from '../../services/UrlSyncManager';\n\n/**\n * Get the closest node with variables\n */\nexport function getVariables(sceneObject: SceneObject): SceneVariables {\n  return getClosest(sceneObject, (s) => s.state.$variables) ?? EmptyVariableSet;\n}\n\n/**\n * Will walk up the scene object graph to the closest $data scene object\n */\nexport function getData(sceneObject: SceneObject): SceneDataProvider {\n  return getClosest(sceneObject, (s) => s.state.$data) ?? EmptyDataNode;\n}\n\nfunction isSceneLayout(s: SceneObject): s is SceneLayout {\n  return 'isDraggable' in s;\n}\n\n/**\n * Will walk up the scene object graph to the closest $layout scene object\n */\nexport function getLayout(scene: SceneObject): SceneLayout | null {\n  const parent = getClosest(scene, (s) => (isSceneLayout(s) ? s : undefined));\n  if (parent) {\n    return parent;\n  }\n\n  return null;\n}\n\n/**\n * Interpolates the given string using the current scene object as context.   *\n *\n * Note: the interpolations array will be mutated by adding information about variables that\n * have been interpolated during replacement. Variables that were specified in the target but not found in\n * the list of available variables are also added to the array. See {@link VariableInterpolation} for more details.\n *\n * @param {VariableInterpolation[]} interpolations an optional array that is updated with interpolated variables.\n */\nexport function interpolate(\n  sceneObject: SceneObject,\n  value: string | undefined | null,\n  scopedVars?: ScopedVars,\n  format?: string | VariableCustomFormatterFn,\n  interpolations?: VariableInterpolation[]\n): string {\n  if (value === '' || value == null) {\n    return '';\n  }\n\n  return sceneInterpolator(sceneObject, value, scopedVars, format, interpolations);\n}\n\n/**\n * Checks if the variable is currently loading or waiting to update.\n * It also returns true if a dependency of the variable is loading.\n *\n * For example if C depends on variable B which depends on variable A and A is loading this returns true for variable C and B.\n */\nexport function hasVariableDependencyInLoadingState(sceneObject: SceneObject) {\n  if (!sceneObject.variableDependency) {\n    return false;\n  }\n\n  for (const name of sceneObject.variableDependency.getNames()) {\n    // This is for backwards compability. In the old architecture query variables could reference itself in a query without breaking.\n    if (sceneObject instanceof QueryVariable && sceneObject.state.name === name) {\n      console.warn('Query variable is referencing itself');\n      continue;\n    }\n\n    const variable = lookupVariable(name, sceneObject);\n    if (!variable) {\n      continue;\n    }\n\n    const set = variable.parent as SceneVariables;\n    if (set.isVariableLoadingOrWaitingToUpdate(variable)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction findObjectInternal(\n  scene: SceneObject,\n  check: (obj: SceneObject) => boolean,\n  alreadySearchedChild?: SceneObject,\n  shouldSearchUp?: boolean\n): SceneObject | null {\n  if (check(scene)) {\n    return scene;\n  }\n\n  let found: SceneObject | null = null;\n\n  scene.forEachChild((child) => {\n    if (child === alreadySearchedChild) {\n      return;\n    }\n\n    let maybe = findObjectInternal(child, check);\n    if (maybe) {\n      found = maybe;\n    }\n  });\n\n  if (found) {\n    return found;\n  }\n\n  if (shouldSearchUp && scene.parent) {\n    return findObjectInternal(scene.parent, check, scene, true);\n  }\n\n  return null;\n}\n\n/**\n * Returns a scene object from the scene graph with the requested key.\n *\n * Throws error if no key-matching scene object found.\n */\nexport function findByKey(sceneObject: SceneObject, key: string) {\n  const found = findObject(sceneObject, (sceneToCheck) => {\n    return sceneToCheck.state.key === key;\n  });\n  if (!found) {\n    throw new Error('Unable to find scene with key ' + key);\n  }\n  return found;\n}\n\n/**\n * Returns a scene object from the scene graph with the requested key and type.\n *\n * Throws error if no key-matching scene object found.\n * Throws error if the given type does not match.\n */\nexport function findByKeyAndType<TargetType extends SceneObject>(\n  sceneObject: SceneObject,\n  key: string,\n  targetType: { new (...args: never[]): TargetType }\n) {\n  const found = findObject(sceneObject, (sceneToCheck) => {\n    return sceneToCheck.state.key === key;\n  });\n  if (!found) {\n    throw new Error('Unable to find scene with key ' + key);\n  }\n  if (!(found instanceof targetType)) {\n    throw new Error(`Found scene object with key ${key} does not match type ${targetType.name}`);\n  }\n  return found;\n}\n\n/**\n * This will search the full scene graph, starting with the scene node passed in, then walking up the parent chain. *\n */\nexport function findObject(scene: SceneObject, check: (obj: SceneObject) => boolean): SceneObject | null {\n  return findObjectInternal(scene, check, undefined, true);\n}\n\n/**\n * This will search down the full scene graph, looking for objects that match the provided predicate.\n */\nexport function findAllObjects(scene: SceneObject, check: (obj: SceneObject) => boolean): SceneObject[] {\n  const found: SceneObject[] = [];\n\n  scene.forEachChild((child) => {\n    if (check(child)) {\n      found.push(child);\n    }\n\n    found.push(...findAllObjects(child, check));\n  });\n\n  return found;\n}\n\n/**\n * Will walk up the scene object graph up until the root and collect all SceneDataLayerProvider objects.\n * When localOnly set to true, it will only collect the closest layers.\n */\nexport function getDataLayers(sceneObject: SceneObject, localOnly = false): SceneDataLayerProvider[] {\n  let currentLevel: SceneObject | undefined = sceneObject;\n  let collected: SceneDataLayerProvider[] = [];\n\n  while (currentLevel) {\n    const dataProvider = currentLevel.state.$data;\n    if (!dataProvider) {\n      currentLevel = currentLevel.parent;\n      continue;\n    }\n\n    // Check if data layer exists nested inside another data provider\n    if (isDataLayer(dataProvider)) {\n      collected = collected.concat(dataProvider);\n    } else {\n      if (dataProvider.state.$data && isDataLayer(dataProvider.state.$data)) {\n        collected = collected.concat(dataProvider.state.$data);\n      }\n    }\n\n    if (localOnly && collected.length > 0) {\n      break;\n    }\n\n    currentLevel = currentLevel.parent;\n  }\n\n  return collected;\n}\n\ninterface SceneType<T> extends Function {\n  new (...args: never[]): T;\n}\n\n/**\n * A utility function to find the closest ancestor of a given type. This function expects\n * to find it and will throw an error if it does not.\n */\nexport function getAncestor<ParentType>(sceneObject: SceneObject, ancestorType: SceneType<ParentType>): ParentType {\n  let parent: SceneObject | undefined = sceneObject;\n\n  while (parent) {\n    if (parent instanceof ancestorType) {\n      return parent;\n    }\n    parent = parent.parent;\n  }\n\n  if (!parent) {\n    throw new Error('Unable to find parent of type ' + ancestorType.name);\n  }\n\n  return parent as ParentType;\n}\n\n/**\n * This will search down the full scene graph, looking for objects that match the provided descendentType type.\n */\nexport function findDescendents<T extends SceneObject>(scene: SceneObject, descendentType: SceneType<T>) {\n  function isDescendentType(scene: SceneObject): scene is T {\n    return scene instanceof descendentType;\n  }\n\n  const targetScenes = findAllObjects(scene, isDescendentType);\n  return targetScenes.filter(isDescendentType);\n}\n\n/**\n * Returns the closest query controller undefined if none found\n */\nexport function getQueryController(sceneObject: SceneObject): SceneQueryControllerLike | undefined {\n  let parent: SceneObject | undefined = sceneObject;\n\n  while (parent) {\n    if (parent.state.$behaviors) {\n      for (const behavior of parent.state.$behaviors) {\n        if (isQueryController(behavior)) {\n          return behavior;\n        }\n      }\n    }\n    parent = parent.parent;\n  }\n\n  return undefined;\n}\n\n/**\n * Returns the closest SceneObject that has a state property with the\n * name urlSyncManager that is of type UrlSyncManager\n */\nexport function getUrlSyncManager(sceneObject: SceneObject): UrlSyncManagerLike | undefined {\n  let parent: SceneObject | undefined = sceneObject;\n\n  while (parent) {\n    if ('urlSyncManager' in parent.state) {\n      return parent.state.urlSyncManager as UrlSyncManagerLike;\n    }\n    parent = parent.parent;\n  }\n\n  return undefined;\n}\n"],"names":["scene"],"mappings":"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"}

package/dist/esm/src/core/sceneGraph/utils.js

@@ -0,0 +1,64 @@
+import { SceneObjectBase } from '../SceneObjectBase.js';
+import { SceneObjectRef } from '../SceneObjectRef.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;
+};
+function cloneSceneObject(sceneObject, withState) {
+  const clonedState = cloneSceneObjectState(sceneObject.state, withState);
+  return new sceneObject.constructor(clonedState);
+}
+function cloneSceneObjectState(sceneState, withState) {
+  const clonedState = __spreadValues({}, sceneState);
+  Object.assign(clonedState, withState);
+  for (const key in clonedState) {
+    if (withState && withState[key] !== void 0) {
+      continue;
+    }
+    const propValue = clonedState[key];
+    if (propValue instanceof SceneObjectBase) {
+      clonedState[key] = propValue.clone();
+    }
+    if (propValue instanceof SceneObjectRef) {
+      console.warn("Cloning object with SceneObjectRef");
+      continue;
+    }
+    if (Array.isArray(propValue)) {
+      const newArray = [];
+      for (const child of propValue) {
+        if (child instanceof SceneObjectBase) {
+          newArray.push(child.clone());
+        } else {
+          newArray.push(child);
+        }
+      }
+      clonedState[key] = newArray;
+    }
+  }
+  return clonedState;
+}
+function getClosest(sceneObject, extract) {
+  let curSceneObject = sceneObject;
+  let extracted = void 0;
+  while (curSceneObject && !extracted) {
+    extracted = extract(curSceneObject);
+    curSceneObject = curSceneObject.parent;
+  }
+  return extracted;
+}
+
+export { cloneSceneObject, cloneSceneObjectState, getClosest };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,15 @@
+function isSceneObject(obj) {
+  return obj.useState !== void 0;
+}
+function isDataRequestEnricher(obj) {
+  return "enrichDataRequest" in obj;
+}
+function isFiltersRequestEnricher(obj) {
+  return "enrichFiltersRequest" in obj;
+}
+function isDataLayer(obj) {
+  return "isDataLayer" in obj;
+}
+
+export { isDataLayer, isDataRequestEnricher, isFiltersRequestEnricher, isSceneObject };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"types.js","sources":["../../../../src/core/types.ts"],"sourcesContent":["import React from 'react';\nimport { MonoTypeOperatorFunction, Observable, Unsubscribable } from 'rxjs';\n\nimport {\n  BusEvent,\n  BusEventHandler,\n  BusEventType,\n  DataFrame,\n  DataQueryRequest,\n  DataSourceGetTagKeysOptions,\n  DataSourceGetTagValuesOptions,\n  DataTransformContext,\n  PanelData,\n  TimeRange,\n} from '@grafana/data';\nimport { DataQuery, DataTopic, TimeZone } from '@grafana/schema';\n\nimport { SceneVariableDependencyConfigLike, SceneVariables } from '../variables/types';\nimport { SceneObjectRef } from './SceneObjectRef';\n\nexport interface SceneObjectState {\n  key?: string;\n  $timeRange?: SceneTimeRangeLike;\n  $data?: SceneDataProvider;\n  $variables?: SceneVariables;\n  /**\n   * @experimental\n   * Can be used to add extra behaviors to a scene object.\n   * These are activated when the their parent scene object is activated.\n   */\n  $behaviors?: Array<SceneObject | SceneStatelessBehavior>;\n}\n\nexport interface SceneLayoutChildOptions {\n  width?: number | string;\n  height?: number | string;\n  xSizing?: 'fill' | 'content';\n  ySizing?: 'fill' | 'content';\n  x?: number;\n  y?: number;\n  minWidth?: number | string;\n  minHeight?: number | string;\n  isDraggable?: boolean;\n  isResizable?: boolean;\n}\n\nexport interface SceneComponentProps<T> {\n  model: T;\n}\n\nexport type SceneComponent<TModel> = (props: SceneComponentProps<TModel>) => React.ReactElement | null;\n\nexport interface SceneDataState extends SceneObjectState {\n  data?: PanelData;\n}\n\nexport interface SceneObject<TState extends SceneObjectState = SceneObjectState> {\n  /** The current state */\n  readonly state: TState;\n\n  /** True when there is a React component mounted for this Object */\n  readonly isActive: boolean;\n\n  /** Controls if activation blocks rendering */\n  readonly renderBeforeActivation: boolean;\n\n  /** SceneObject parent */\n  readonly parent?: SceneObject;\n\n  /** This abtractions declares what variables the scene object depends on and how to handle when they change value. **/\n  readonly variableDependency?: SceneVariableDependencyConfigLike;\n\n  /** This abstraction declares URL sync dependencies of a scene object. **/\n  readonly urlSync?: SceneObjectUrlSyncHandler;\n\n  /** Subscribe to state changes */\n  subscribeToState(handler: SceneStateChangedHandler<TState>): Unsubscribable;\n\n  /** Subscribe to a scene event */\n  subscribeToEvent<T extends BusEvent>(typeFilter: BusEventType<T>, handler: BusEventHandler<T>): Unsubscribable;\n\n  /** Publish an event and optionally bubble it up the scene */\n  publishEvent(event: BusEvent, bubble?: boolean): void;\n\n  /** Utility hook that wraps useObservable. Used by React components to subscribes to state changes */\n  useState(): TState;\n\n  /** How to modify state */\n  setState(state: Partial<TState>): void;\n\n  /**\n   * Called when the Component is mounted. This will also activate any $data, $variables or $timeRange scene object on this level.\n   * Don't override this in your custom SceneObjects, instead use addActivationHandler from the constructor.\n   **/\n  activate(): CancelActivationHandler;\n\n  /** Get the scene root */\n  getRoot(): SceneObject;\n\n  /** Returns a deep clone this object and all its children */\n  clone(state?: Partial<TState>): this;\n\n  /** A React component to use for rendering the object */\n  Component(props: SceneComponentProps<SceneObject<TState>>): React.ReactElement | null;\n\n  /** Force a re-render, should only be needed when variable values change */\n  forceRender(): void;\n\n  /** Returns a SceneObjectRef that will resolve to this object */\n  getRef(): SceneObjectRef<this>;\n\n  /**\n   * Allows external code to register code that is executed on activate and deactivate. This allow you\n   * to wire up scene objects that need to respond to state changes in other objects from the outside.\n   **/\n  addActivationHandler(handler: SceneActivationHandler): void;\n\n  /**\n   * Loop through state and call callback for each direct child scene object.\n   * Checks 1 level deep properties and arrays. So a scene object hidden in a nested plain object will not be detected.\n   */\n  forEachChild(callback: (child: SceneObject) => void): void;\n\n  /**\n   * Useful for edge cases when you want to move a scene object to another parent.\n   */\n  clearParent(): void;\n}\n\nexport type SceneActivationHandler = () => SceneDeactivationHandler | void;\nexport type SceneDeactivationHandler = () => void;\n\n/**\n * Function returned by activate() that when called will deactivate the object if it's the last activator\n **/\nexport type CancelActivationHandler = () => void;\n\nexport interface SceneLayoutState extends SceneObjectState {\n  children: SceneObject[];\n}\n\nexport interface SceneLayout<T extends SceneLayoutState = SceneLayoutState> extends SceneObject<T> {\n  isDraggable(): boolean;\n  getDragClass?(): string;\n  getDragClassCancel?(): string;\n}\n\nexport interface SceneTimeRangeState extends SceneObjectState {\n  from: string;\n  to: string;\n  fiscalYearStartMonth?: number;\n  value: TimeRange;\n  timeZone?: TimeZone;\n  /** weekStart will change the global date locale so having multiple different weekStart values is not supported  */\n  weekStart?: string;\n  /**\n   * @internal\n   * To enable feature parity with the old time range picker, not sure if it will be kept.\n   * Override the now time by entering a time delay. Use this option to accommodate known delays in data aggregation to avoid null values.\n   * */\n  UNSAFE_nowDelay?: string;\n\n  refreshOnActivate?: {\n    /**\n     * When set, the time range will invalidate relative ranges after the specified interval has elapsed\n     */\n    afterMs?: number;\n    /**\n     * When set, the time range will invalidate relative ranges after the specified percentage of the current interval has elapsed.\n     * If both invalidate values are set, the smaller value will be used for the given interval.\n     */\n    percent?: number;\n  };\n}\n\nexport interface SceneTimeRangeLike extends SceneObject<SceneTimeRangeState> {\n  onTimeZoneChange(timeZone: TimeZone): void;\n  onTimeRangeChange(timeRange: TimeRange): void;\n  onRefresh(): void;\n  getTimeZone(): TimeZone;\n}\n\nexport function isSceneObject(obj: any): obj is SceneObject {\n  return obj.useState !== undefined;\n}\n\nexport interface SceneObjectWithUrlSync extends SceneObject {\n  getUrlState(): SceneObjectUrlValues;\n  updateFromUrl(values: SceneObjectUrlValues): void;\n  shouldCreateHistoryStep?(values: SceneObjectUrlValues): boolean;\n}\n\nexport interface SceneObjectUrlSyncHandler {\n  getKeys(): string[];\n  getUrlState(): SceneObjectUrlValues;\n  updateFromUrl(values: SceneObjectUrlValues): void;\n  shouldCreateHistoryStep?(values: SceneObjectUrlValues): boolean;\n}\n\nexport interface DataRequestEnricher {\n  // Return partial data query request that will be merged with the original request provided by SceneQueryRunner\n  enrichDataRequest(source: SceneObject): Partial<DataQueryRequest> | null;\n}\n\nexport interface FiltersRequestEnricher {\n  // Return partial getTagKeys or getTagValues query request that will be merged with the original request provided by ad hoc or group by variable\n  enrichFiltersRequest(\n    source: SceneObject\n  ): Partial<DataSourceGetTagKeysOptions | DataSourceGetTagValuesOptions> | null;\n}\n\nexport function isDataRequestEnricher(obj: any): obj is DataRequestEnricher {\n  return 'enrichDataRequest' in obj;\n}\n\nexport function isFiltersRequestEnricher(obj: any): obj is FiltersRequestEnricher {\n  return 'enrichFiltersRequest' in obj;\n}\n\nexport type SceneObjectUrlValue = string | string[] | undefined | null;\nexport type SceneObjectUrlValues = Record<string, SceneObjectUrlValue>;\n\nexport type CustomTransformOperator = (context: DataTransformContext) => MonoTypeOperatorFunction<DataFrame[]>;\nexport type CustomTransformerDefinition =\n  | { operator: CustomTransformOperator; topic: DataTopic }\n  | CustomTransformOperator;\nexport type SceneStateChangedHandler<TState> = (newState: TState, prevState: TState) => void;\n\nexport type DeepPartial<T> = {\n  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];\n};\n\nexport interface SceneDataProviderResult {\n  data: PanelData;\n  origin: SceneDataProvider;\n}\n\nexport interface SceneDataProvider<T extends SceneObjectState = SceneDataState> extends SceneObject<T> {\n  setContainerWidth?: (width: number) => void;\n  isDataReadyToDisplay?: () => boolean;\n  cancelQuery?: () => void;\n  getResultsStream(): Observable<SceneDataProviderResult>;\n}\n\nexport interface SceneDataLayerProviderState extends SceneDataState {\n  name: string;\n  description?: string;\n  isEnabled?: boolean;\n  isHidden?: boolean;\n}\n\nexport interface SceneDataLayerProvider extends SceneDataProvider<SceneDataLayerProviderState> {\n  isDataLayer: true;\n}\n\nexport function isDataLayer(obj: SceneObject): obj is SceneDataLayerProvider {\n  return 'isDataLayer' in obj;\n}\n\nexport interface DataLayerFilter {\n  panelId: number;\n}\n\nexport interface SceneStatelessBehavior<T extends SceneObject = any> {\n  (sceneObject: T): CancelActivationHandler | void;\n}\n\nexport type ControlsLayout = 'horizontal' | 'vertical';\n\nexport interface UseStateHookOptions {\n  /**\n   * For some edge cases other scene objects want to subscribe to scene object state for objects\n   * that are not active, or whose main React Component can be un-mounted. Set this to true\n   * to keep the scene object active even if the React component is unmounted.\n   *\n   * Normally you would not need this but this can be useful in some edge cases.\n   *\n   * @experimental\n   */\n  shouldActivateOrKeepAlive?: boolean;\n}\n\nexport interface SceneDataQuery extends DataQuery {\n  [key: string]: any;\n\n  // Opt this query out of time window comparison\n  timeRangeCompare?: boolean;\n}\n\nexport interface SceneUrlSyncOptions {\n  /**\n   * This will update the url to contain all scene url state\n   * when the scene is initialized. Important for browser history \"back\" actions.\n   */\n  updateUrlOnInit?: boolean;\n  /**\n   * This is only supported by some objects if they implement\n   * shouldCreateHistoryStep where they can control what changes\n   * url changes should add a new browser history entry.\n   */\n  createBrowserHistorySteps?: boolean;\n}\n"],"names":[],"mappings":"AAsLO,SAAS,cAAc,GAA8B,EAAA;AAC1D,EAAA,OAAO,IAAI,QAAa,KAAA,KAAA,CAAA,CAAA;AAC1B,CAAA;AA2BO,SAAS,sBAAsB,GAAsC,EAAA;AAC1E,EAAA,OAAO,mBAAuB,IAAA,GAAA,CAAA;AAChC,CAAA;AAEO,SAAS,yBAAyB,GAAyC,EAAA;AAChF,EAAA,OAAO,sBAA0B,IAAA,GAAA,CAAA;AACnC,CAAA;AAsCO,SAAS,YAAY,GAAiD,EAAA;AAC3E,EAAA,OAAO,aAAiB,IAAA,GAAA,CAAA;AAC1B;;;;"}

package/dist/esm/src/index.js

@@ -0,0 +1,108 @@
+import { getUrlWithAppState } from './components/SceneApp/utils.js';
+import { registerRuntimePanelPlugin } from './components/VizPanel/registerRuntimePanelPlugin.js';
+import { cloneSceneObjectState } from './core/sceneGraph/utils.js';
+import { registerRuntimeDataSource } from './querying/RuntimeDataSource.js';
+export { RuntimeDataSource, registerRuntimeDataSource } from './querying/RuntimeDataSource.js';
+import { syncStateFromSearchParams, getUrlState } from './services/utils.js';
+import { registerVariableMacro } from './variables/macros/index.js';
+import { renderPrometheusLabelFilters } from './variables/utils.js';
+import { isAdHocVariable, isConstantVariable, isCustomVariable, isDataSourceVariable, isIntervalVariable, isQueryVariable, isTextBoxVariable, isGroupByVariable } from './variables/variants/guards.js';
+export { isDataLayer, isDataRequestEnricher, isFiltersRequestEnricher, isSceneObject } from './core/types.js';
+export { SceneObjectStateChangedEvent, UserActionEvent } from './core/events.js';
+export { sceneGraph } from './core/sceneGraph/index.js';
+import * as index from './behaviors/index.js';
+export { index as behaviors };
+import * as index$1 from './querying/layers/index.js';
+export { index$1 as dataLayers };
+export { SceneObjectBase, useSceneObjectState } from './core/SceneObjectBase.js';
+export { SceneDataNode } from './core/SceneDataNode.js';
+export { SceneTimeRange } from './core/SceneTimeRange.js';
+export { SceneTimeZoneOverride } from './core/SceneTimeZoneOverride.js';
+export { SceneQueryRunner } from './querying/SceneQueryRunner.js';
+export { DataProviderProxy } from './querying/DataProviderProxy.js';
+export { SceneDataLayerSet, SceneDataLayerSetBase } from './querying/SceneDataLayerSet.js';
+export { SceneDataLayerBase } from './querying/layers/SceneDataLayerBase.js';
+export { SceneDataLayerControls } from './querying/layers/SceneDataLayerControls.js';
+export { SceneDataTransformer } from './querying/SceneDataTransformer.js';
+export { registerQueryWithController } from './querying/registerQueryWithController.js';
+export { SceneVariableValueChangedEvent, isCustomVariableValue } from './variables/types.js';
+export { VariableDependencyConfig } from './variables/VariableDependencyConfig.js';
+export { formatRegistry } from './variables/interpolation/formatRegistry.js';
+export { VariableValueSelectWrapper, VariableValueSelectors } from './variables/components/VariableValueSelectors.js';
+export { VariableValueControl } from './variables/components/VariableValueControl.js';
+export { SceneVariableSet } from './variables/sets/SceneVariableSet.js';
+export { ConstantVariable } from './variables/variants/ConstantVariable.js';
+export { CustomVariable } from './variables/variants/CustomVariable.js';
+export { DataSourceVariable } from './variables/variants/DataSourceVariable.js';
+export { QueryVariable } from './variables/variants/query/QueryVariable.js';
+export { TestVariable } from './variables/variants/TestVariable.js';
+export { TextBoxVariable } from './variables/variants/TextBoxVariable.js';
+export { JsonStringOptionPrivider, JsonVariable } from './variables/variants/JsonVariable.js';
+export { MultiValueVariable } from './variables/variants/MultiValueVariable.js';
+export { LocalValueVariable } from './variables/variants/LocalValueVariable.js';
+export { IntervalVariable } from './variables/variants/IntervalVariable.js';
+export { AdHocFiltersVariable } from './variables/adhoc/AdHocFiltersVariable.js';
+export { GroupByVariable } from './variables/groupby/GroupByVariable.js';
+export { NewSceneObjectAddedEvent, UrlSyncManager } from './services/UrlSyncManager.js';
+export { useUrlSync } from './services/useUrlSync.js';
+export { UrlSyncContextProvider } from './services/UrlSyncContextProvider.js';
+export { SceneObjectUrlSyncConfig } from './services/SceneObjectUrlSyncConfig.js';
+export { EmbeddedScene } from './components/EmbeddedScene.js';
+export { VizPanel } from './components/VizPanel/VizPanel.js';
+export { VizPanelMenu } from './components/VizPanel/VizPanelMenu.js';
+export { VizPanelExploreButton } from './components/VizPanel/VizPanelExploreButton.js';
+export { NestedScene } from './components/NestedScene.js';
+export { SceneCanvasText } from './components/SceneCanvasText.js';
+export { SceneToolbarButton, SceneToolbarInput } from './components/SceneToolbarButton.js';
+export { SceneTimePicker } from './components/SceneTimePicker.js';
+export { SceneRefreshPicker } from './components/SceneRefreshPicker.js';
+export { SceneTimeRangeTransformerBase } from './core/SceneTimeRangeTransformerBase.js';
+export { SceneTimeRangeCompare } from './components/SceneTimeRangeCompare.js';
+export { SceneByFrameRepeater } from './components/SceneByFrameRepeater.js';
+export { SceneByVariableRepeater } from './components/SceneByVariableRepeater.js';
+export { SceneControlsSpacer } from './components/SceneControlsSpacer.js';
+export { SceneFlexItem, SceneFlexLayout } from './components/layout/SceneFlexLayout.js';
+export { SceneCSSGridItem, SceneCSSGridLayout } from './components/layout/CSSGrid/SceneCSSGridLayout.js';
+export { SceneGridLayout } from './components/layout/grid/SceneGridLayout.js';
+export { SceneGridItem } from './components/layout/grid/SceneGridItem.js';
+export { SceneGridRow } from './components/layout/grid/SceneGridRow.js';
+export { SplitLayout } from './components/layout/split/SplitLayout.js';
+export { SceneApp, useSceneApp } from './components/SceneApp/SceneApp.js';
+export { SceneAppPage } from './components/SceneApp/SceneAppPage.js';
+export { SceneReactObject } from './components/SceneReactObject.js';
+export { SceneObjectRef } from './core/SceneObjectRef.js';
+export { PanelBuilders } from './core/PanelBuilders/index.js';
+export { FieldConfigBuilder } from './core/PanelBuilders/FieldConfigBuilder.js';
+export { VizPanelBuilder } from './core/PanelBuilders/VizPanelBuilder.js';
+export { SceneDebugger } from './components/SceneDebugger/SceneDebugger.js';
+export { ControlsLabel } from './utils/ControlsLabel.js';
+export { renderSelectForVariable } from './variables/components/VariableValueSelect.js';
+export { VizConfigBuilder } from './core/PanelBuilders/VizConfigBuilder.js';
+export { VizConfigBuilders } from './core/PanelBuilders/VizConfigBuilders.js';
+export { SafeSerializableSceneObject } from './utils/SafeSerializableSceneObject.js';
+export { getExploreURL } from './utils/explore.js';
+export { PanelOptionsBuilders } from './core/PanelBuilders/PanelOptionsBuilders.js';
+export { FieldConfigBuilders } from './core/PanelBuilders/FieldConfigBuilders.js';
+export { FieldConfigOverridesBuilder } from './core/PanelBuilders/FieldConfigOverridesBuilder.js';
+
+const sceneUtils = {
+  getUrlWithAppState,
+  registerRuntimePanelPlugin,
+  registerRuntimeDataSource,
+  registerVariableMacro,
+  cloneSceneObjectState,
+  syncStateFromSearchParams,
+  getUrlState,
+  renderPrometheusLabelFilters,
+  isAdHocVariable,
+  isConstantVariable,
+  isCustomVariable,
+  isDataSourceVariable,
+  isIntervalVariable,
+  isQueryVariable,
+  isTextBoxVariable,
+  isGroupByVariable
+};
+
+export { sceneUtils };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","sources":["../../../src/index.ts"],"sourcesContent":["import { getUrlWithAppState } from './components/SceneApp/utils';\nimport { registerRuntimePanelPlugin } from './components/VizPanel/registerRuntimePanelPlugin';\nimport { cloneSceneObjectState } from './core/sceneGraph/utils';\nimport { registerRuntimeDataSource } from './querying/RuntimeDataSource';\nimport { getUrlState, syncStateFromSearchParams } from './services/utils';\n\nimport { registerVariableMacro } from './variables/macros';\nimport { renderPrometheusLabelFilters } from './variables/utils';\nimport {\n  isAdHocVariable,\n  isQueryVariable,\n  isTextBoxVariable,\n  isCustomVariable,\n  isDataSourceVariable,\n  isConstantVariable,\n  isIntervalVariable,\n  isGroupByVariable,\n} from './variables/variants/guards';\n\nexport * from './core/types';\nexport * from './core/events';\nexport { sceneGraph } from './core/sceneGraph';\nexport * as behaviors from './behaviors';\nexport * as dataLayers from './querying/layers';\n\nexport { SceneObjectBase, useSceneObjectState } from './core/SceneObjectBase';\nexport { SceneDataNode } from './core/SceneDataNode';\nexport { SceneTimeRange } from './core/SceneTimeRange';\nexport { SceneTimeZoneOverride } from './core/SceneTimeZoneOverride';\n\nexport { SceneQueryRunner, type QueryRunnerState } from './querying/SceneQueryRunner';\nexport { DataProviderProxy } from './querying/DataProviderProxy';\nexport {\n  type ExtraQueryDescriptor,\n  type ExtraQueryProvider,\n  type ExtraQueryDataProcessor,\n} from './querying/ExtraQueryProvider';\nexport { SceneDataLayerSet, SceneDataLayerSetBase } from './querying/SceneDataLayerSet';\nexport { SceneDataLayerBase } from './querying/layers/SceneDataLayerBase';\nexport { SceneDataLayerControls } from './querying/layers/SceneDataLayerControls';\nexport { SceneDataTransformer, type SceneDataTransformerState } from './querying/SceneDataTransformer';\nexport { registerQueryWithController } from './querying/registerQueryWithController';\nexport { registerRuntimeDataSource, RuntimeDataSource } from './querying/RuntimeDataSource';\nexport type {\n  SceneQueryControllerLike,\n  SceneQueryControllerEntryType,\n  SceneQueryControllerEntry,\n} from './behaviors/SceneQueryController';\n\nexport * from './variables/types';\nexport { VariableDependencyConfig } from './variables/VariableDependencyConfig';\nexport { formatRegistry, type FormatVariable } from './variables/interpolation/formatRegistry';\nexport { VariableValueSelectors } from './variables/components/VariableValueSelectors';\nexport { VariableValueControl } from './variables/components/VariableValueControl';\nexport { SceneVariableSet } from './variables/sets/SceneVariableSet';\nexport { ConstantVariable } from './variables/variants/ConstantVariable';\nexport { CustomVariable } from './variables/variants/CustomVariable';\nexport { DataSourceVariable } from './variables/variants/DataSourceVariable';\nexport { QueryVariable } from './variables/variants/query/QueryVariable';\nexport { TestVariable } from './variables/variants/TestVariable';\nexport { TextBoxVariable } from './variables/variants/TextBoxVariable';\nexport { JsonVariable, JsonStringOptionPrivider } from './variables/variants/JsonVariable';\nexport {\n  MultiValueVariable,\n  type MultiValueVariableState,\n  type VariableGetOptionsArgs,\n} from './variables/variants/MultiValueVariable';\nexport { LocalValueVariable } from './variables/variants/LocalValueVariable';\nexport { IntervalVariable } from './variables/variants/IntervalVariable';\nexport { AdHocFiltersVariable } from './variables/adhoc/AdHocFiltersVariable';\nexport { GroupByVariable } from './variables/groupby/GroupByVariable';\nexport { type MacroVariableConstructor } from './variables/macros/types';\n\nexport { type UrlSyncManagerLike, UrlSyncManager, NewSceneObjectAddedEvent } from './services/UrlSyncManager';\nexport { useUrlSync } from './services/useUrlSync';\nexport { UrlSyncContextProvider } from './services/UrlSyncContextProvider';\nexport { SceneObjectUrlSyncConfig } from './services/SceneObjectUrlSyncConfig';\n\nexport { EmbeddedScene, type EmbeddedSceneState } from './components/EmbeddedScene';\nexport { VizPanel, type VizPanelState } from './components/VizPanel/VizPanel';\nexport { VizPanelMenu } from './components/VizPanel/VizPanelMenu';\nexport { VizPanelExploreButton } from './components/VizPanel/VizPanelExploreButton';\nexport { NestedScene } from './components/NestedScene';\nexport { SceneCanvasText } from './components/SceneCanvasText';\nexport { SceneToolbarButton, SceneToolbarInput } from './components/SceneToolbarButton';\nexport { SceneTimePicker } from './components/SceneTimePicker';\nexport { SceneRefreshPicker, type SceneRefreshPickerState } from './components/SceneRefreshPicker';\nexport { SceneTimeRangeTransformerBase } from './core/SceneTimeRangeTransformerBase';\nexport { SceneTimeRangeCompare } from './components/SceneTimeRangeCompare';\nexport { SceneByFrameRepeater } from './components/SceneByFrameRepeater';\nexport { SceneByVariableRepeater } from './components/SceneByVariableRepeater';\nexport { SceneControlsSpacer } from './components/SceneControlsSpacer';\nexport {\n  SceneFlexLayout,\n  SceneFlexItem,\n  type SceneFlexItemState,\n  type SceneFlexItemLike,\n} from './components/layout/SceneFlexLayout';\nexport { SceneCSSGridLayout, SceneCSSGridItem } from './components/layout/CSSGrid/SceneCSSGridLayout';\nexport { SceneGridLayout } from './components/layout/grid/SceneGridLayout';\nexport { SceneGridItem } from './components/layout/grid/SceneGridItem';\nexport { SceneGridRow } from './components/layout/grid/SceneGridRow';\nexport { type SceneGridItemStateLike, type SceneGridItemLike } from './components/layout/grid/types';\nexport { SplitLayout } from './components/layout/split/SplitLayout';\nexport {\n  type SceneAppPageLike,\n  type SceneRouteMatch,\n  type SceneAppPageState,\n  type SceneAppDrilldownView,\n  type SceneAppRoute,\n} from './components/SceneApp/types';\nexport { SceneApp, useSceneApp } from './components/SceneApp/SceneApp';\nexport { SceneAppPage } from './components/SceneApp/SceneAppPage';\nexport { SceneReactObject } from './components/SceneReactObject';\nexport { SceneObjectRef } from './core/SceneObjectRef';\nexport {\n  PanelBuilders,\n  PanelOptionsBuilders,\n  FieldConfigBuilders,\n  FieldConfigOverridesBuilder,\n} from './core/PanelBuilders';\nexport { FieldConfigBuilder } from './core/PanelBuilders/FieldConfigBuilder';\nexport { VizPanelBuilder } from './core/PanelBuilders/VizPanelBuilder';\nexport { SceneDebugger } from './components/SceneDebugger/SceneDebugger';\nexport { VariableValueSelectWrapper } from './variables/components/VariableValueSelectors';\nexport { ControlsLabel } from './utils/ControlsLabel';\nexport { renderSelectForVariable } from './variables/components/VariableValueSelect';\nexport { VizConfigBuilder } from './core/PanelBuilders/VizConfigBuilder';\nexport { VizConfigBuilders } from './core/PanelBuilders/VizConfigBuilders';\nexport { type VizConfig } from './core/PanelBuilders/types';\n\nexport const sceneUtils = {\n  getUrlWithAppState,\n  registerRuntimePanelPlugin,\n  registerRuntimeDataSource,\n  registerVariableMacro,\n  cloneSceneObjectState,\n  syncStateFromSearchParams,\n  getUrlState,\n  renderPrometheusLabelFilters,\n\n  // Variable guards\n  isAdHocVariable,\n  isConstantVariable,\n  isCustomVariable,\n  isDataSourceVariable,\n  isIntervalVariable,\n  isQueryVariable,\n  isTextBoxVariable,\n  isGroupByVariable,\n};\n\nexport { SafeSerializableSceneObject } from './utils/SafeSerializableSceneObject';\nexport { getExploreURL } from './utils/explore';\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmIO,MAAM,UAAa,GAAA;AAAA,EACxB,kBAAA;AAAA,EACA,0BAAA;AAAA,EACA,yBAAA;AAAA,EACA,qBAAA;AAAA,EACA,qBAAA;AAAA,EACA,yBAAA;AAAA,EACA,WAAA;AAAA,EACA,4BAAA;AAAA,EAGA,eAAA;AAAA,EACA,kBAAA;AAAA,EACA,gBAAA;AAAA,EACA,oBAAA;AAAA,EACA,kBAAA;AAAA,EACA,eAAA;AAAA,EACA,iBAAA;AAAA,EACA,iBAAA;AACF;;;;"}