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

package/dist/esm/src/behaviors/LiveNowTimer.js

@@ -0,0 +1,44 @@
+import { VizPanel } from '../components/VizPanel/VizPanel.js';
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+import { sceneGraph } from '../core/sceneGraph/index.js';
+
+const _LiveNowTimer = class extends SceneObjectBase {
+  constructor({ enabled = false }) {
+    super({ enabled });
+    this.timerId = void 0;
+    this._activationHandler = () => {
+      if (this.state.enabled) {
+        this.enable();
+      }
+      return () => {
+        window.clearInterval(this.timerId);
+        this.timerId = void 0;
+      };
+    };
+    this.addActivationHandler(this._activationHandler);
+  }
+  enable() {
+    window.clearInterval(this.timerId);
+    this.timerId = void 0;
+    this.timerId = window.setInterval(() => {
+      const panels = sceneGraph.findAllObjects(this.getRoot(), (obj) => obj instanceof VizPanel);
+      for (const panel of panels) {
+        panel.forceRender();
+      }
+    }, _LiveNowTimer.REFRESH_RATE);
+    this.setState({ enabled: true });
+  }
+  disable() {
+    window.clearInterval(this.timerId);
+    this.timerId = void 0;
+    this.setState({ enabled: false });
+  }
+  get isEnabled() {
+    return this.state.enabled;
+  }
+};
+let LiveNowTimer = _LiveNowTimer;
+LiveNowTimer.REFRESH_RATE = 100;
+
+export { LiveNowTimer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/behaviors/SceneQueryController.js

@@ -0,0 +1,60 @@
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var _running;
+function isQueryController(s) {
+  return "isQueryController" in s;
+}
+class SceneQueryController extends SceneObjectBase {
+  constructor() {
+    super({ isRunning: false });
+    this.isQueryController = true;
+    __privateAdd(this, _running, /* @__PURE__ */ new Set());
+    this.addActivationHandler(() => {
+      return () => __privateGet(this, _running).clear();
+    });
+  }
+  queryStarted(entry) {
+    __privateGet(this, _running).add(entry);
+    this.changeRunningQueryCount(1);
+    if (!this.state.isRunning) {
+      this.setState({ isRunning: true });
+    }
+  }
+  queryCompleted(entry) {
+    if (!__privateGet(this, _running).has(entry)) {
+      return;
+    }
+    __privateGet(this, _running).delete(entry);
+    this.changeRunningQueryCount(-1);
+    if (__privateGet(this, _running).size === 0) {
+      this.setState({ isRunning: false });
+    }
+  }
+  changeRunningQueryCount(dir) {
+    var _a;
+    window.__grafanaRunningQueryCount = ((_a = window.__grafanaRunningQueryCount) != null ? _a : 0) + dir;
+  }
+  cancelAll() {
+    var _a;
+    for (const entry of __privateGet(this, _running).values()) {
+      (_a = entry.cancel) == null ? void 0 : _a.call(entry);
+    }
+  }
+}
+_running = new WeakMap();
+
+export { SceneQueryController, isQueryController };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2NlbmVRdWVyeUNvbnRyb2xsZXIuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iZWhhdmlvcnMvU2NlbmVRdWVyeUNvbnRyb2xsZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2NlbmVPYmplY3RCYXNlIH0gZnJvbSAnLi4vY29yZS9TY2VuZU9iamVjdEJhc2UnO1xuaW1wb3J0IHsgU2NlbmVPYmplY3QsIFNjZW5lT2JqZWN0U3RhdGUsIFNjZW5lU3RhdGVsZXNzQmVoYXZpb3IgfSBmcm9tICcuLi9jb3JlL3R5cGVzJztcbmltcG9ydCB7IERhdGFRdWVyeVJlcXVlc3QgfSBmcm9tICdAZ3JhZmFuYS9kYXRhJztcbmltcG9ydCB7IExvYWRpbmdTdGF0ZSB9IGZyb20gJ0BncmFmYW5hL3NjaGVtYSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2NlbmVRdWVyeVN0YXRlQ29udHJvbGxlclN0YXRlIGV4dGVuZHMgU2NlbmVPYmplY3RTdGF0ZSB7XG4gIGlzUnVubmluZzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTY2VuZVF1ZXJ5Q29udHJvbGxlckxpa2UgZXh0ZW5kcyBTY2VuZU9iamVjdDxTY2VuZVF1ZXJ5U3RhdGVDb250cm9sbGVyU3RhdGU+IHtcbiAgaXNRdWVyeUNvbnRyb2xsZXI6IHRydWU7XG4gIGNhbmNlbEFsbCgpOiB2b2lkO1xuXG4gIHF1ZXJ5U3RhcnRlZChlbnRyeTogU2NlbmVRdWVyeUNvbnRyb2xsZXJFbnRyeSk6IHZvaWQ7XG4gIHF1ZXJ5Q29tcGxldGVkKGVudHJ5OiBTY2VuZVF1ZXJ5Q29udHJvbGxlckVudHJ5KTogdm9pZDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGlzUXVlcnlDb250cm9sbGVyKHM6IFNjZW5lT2JqZWN0IHwgU2NlbmVTdGF0ZWxlc3NCZWhhdmlvcik6IHMgaXMgU2NlbmVRdWVyeUNvbnRyb2xsZXJMaWtlIHtcbiAgcmV0dXJuICdpc1F1ZXJ5Q29udHJvbGxlcicgaW4gcztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBRdWVyeVJlc3VsdFdpdGhTdGF0ZSB7XG4gIHN0YXRlOiBMb2FkaW5nU3RhdGU7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2NlbmVRdWVyeUNvbnRyb2xsZXJFbnRyeSB7XG4gIHJlcXVlc3Q/OiBEYXRhUXVlcnlSZXF1ZXN0O1xuICB0eXBlOiBTY2VuZVF1ZXJ5Q29udHJvbGxlckVudHJ5VHlwZTtcbiAgb3JpZ2luOiBTY2VuZU9iamVjdDtcbiAgY2FuY2VsPzogKCkgPT4gdm9pZDtcbn1cblxuZXhwb3J0IHR5cGUgU2NlbmVRdWVyeUNvbnRyb2xsZXJFbnRyeVR5cGUgPSAnZGF0YScgfCAnYW5ub3RhdGlvbnMnIHwgJ3ZhcmlhYmxlJyB8ICdhbGVydHMnO1xuXG5leHBvcnQgY2xhc3MgU2NlbmVRdWVyeUNvbnRyb2xsZXJcbiAgZXh0ZW5kcyBTY2VuZU9iamVjdEJhc2U8U2NlbmVRdWVyeVN0YXRlQ29udHJvbGxlclN0YXRlPlxuICBpbXBsZW1lbnRzIFNjZW5lUXVlcnlDb250cm9sbGVyTGlrZVxue1xuICBwdWJsaWMgaXNRdWVyeUNvbnRyb2xsZXI6IHRydWUgPSB0cnVlO1xuXG4gICNydW5uaW5nID0gbmV3IFNldDxTY2VuZVF1ZXJ5Q29udHJvbGxlckVudHJ5PigpO1xuXG4gIHB1YmxpYyBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcih7IGlzUnVubmluZzogZmFsc2UgfSk7XG5cbiAgICAvLyBDbGVhciBydW5uaW5nIHN0YXRlIG9uIGRlYWN0aXZhdGVcbiAgICB0aGlzLmFkZEFjdGl2YXRpb25IYW5kbGVyKCgpID0+IHtcbiAgICAgIHJldHVybiAoKSA9PiB0aGlzLiNydW5uaW5nLmNsZWFyKCk7XG4gICAgfSk7XG4gIH1cblxuICBwdWJsaWMgcXVlcnlTdGFydGVkKGVudHJ5OiBTY2VuZVF1ZXJ5Q29udHJvbGxlckVudHJ5KSB7XG4gICAgdGhpcy4jcnVubmluZy5hZGQoZW50cnkpO1xuXG4gICAgdGhpcy5jaGFuZ2VSdW5uaW5nUXVlcnlDb3VudCgxKTtcblxuICAgIGlmICghdGhpcy5zdGF0ZS5pc1J1bm5pbmcpIHtcbiAgICAgIHRoaXMuc2V0U3RhdGUoeyBpc1J1bm5pbmc6IHRydWUgfSk7XG4gICAgfVxuICB9XG5cbiAgcHVibGljIHF1ZXJ5Q29tcGxldGVkKGVudHJ5OiBTY2VuZVF1ZXJ5Q29udHJvbGxlckVudHJ5KSB7XG4gICAgaWYgKCF0aGlzLiNydW5uaW5nLmhhcyhlbnRyeSkpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICB0aGlzLiNydW5uaW5nLmRlbGV0ZShlbnRyeSk7XG5cbiAgICB0aGlzLmNoYW5nZVJ1bm5pbmdRdWVyeUNvdW50KC0xKTtcblxuICAgIGlmICh0aGlzLiNydW5uaW5nLnNpemUgPT09IDApIHtcbiAgICAgIHRoaXMuc2V0U3RhdGUoeyBpc1J1bm5pbmc6IGZhbHNlIH0pO1xuICAgIH1cbiAgfVxuXG4gIHByaXZhdGUgY2hhbmdlUnVubmluZ1F1ZXJ5Q291bnQoZGlyOiAxIHwgLTEpIHtcbiAgICAvKipcbiAgICAgKiBVc2VkIGJ5IGdyYWZhbmEtaW1hZ2UtcmVuZGVyZXIgdG8ga25vdyB3aGVuIGFsbCBxdWVyaWVzIGFyZSBjb21wbGV0ZWQuXG4gICAgICovXG4gICAgKHdpbmRvdyBhcyBhbnkpLl9fZ3JhZmFuYVJ1bm5pbmdRdWVyeUNvdW50ID0gKCh3aW5kb3cgYXMgYW55KS5fX2dyYWZhbmFSdW5uaW5nUXVlcnlDb3VudCA/PyAwKSArIGRpcjtcbiAgfVxuXG4gIHB1YmxpYyBjYW5jZWxBbGwoKSB7XG4gICAgZm9yIChjb25zdCBlbnRyeSBvZiB0aGlzLiNydW5uaW5nLnZhbHVlcygpKSB7XG4gICAgICBlbnRyeS5jYW5jZWw/LigpO1xuICAgIH1cbiAgfVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7OztBQUFBLElBQUEsUUFBQSxDQUFBO0FBaUJPLFNBQVMsa0JBQWtCLENBQXdFLEVBQUE7QUFDeEcsRUFBQSxPQUFPLG1CQUF1QixJQUFBLENBQUEsQ0FBQTtBQUNoQyxDQUFBO0FBZU8sTUFBTSw2QkFDSCxlQUVWLENBQUE7QUFBQSxFQUtTLFdBQWMsR0FBQTtBQUNuQixJQUFNLEtBQUEsQ0FBQSxFQUFFLFNBQVcsRUFBQSxLQUFBLEVBQU8sQ0FBQSxDQUFBO0FBTDVCLElBQUEsSUFBQSxDQUFPLGlCQUEwQixHQUFBLElBQUEsQ0FBQTtBQUVqQyxJQUFBLFlBQUEsQ0FBQSxJQUFBLEVBQUEsUUFBQSxzQkFBZSxHQUErQixFQUFBLENBQUEsQ0FBQTtBQU01QyxJQUFBLElBQUEsQ0FBSyxxQkFBcUIsTUFBTTtBQUM5QixNQUFPLE9BQUEsTUFBTSxZQUFLLENBQUEsSUFBQSxFQUFBLFFBQUEsQ0FBQSxDQUFTLEtBQU0sRUFBQSxDQUFBO0FBQUEsS0FDbEMsQ0FBQSxDQUFBO0FBQUEsR0FDSDtBQUFBLEVBRU8sYUFBYSxLQUFrQyxFQUFBO0FBQ3BELElBQUssWUFBQSxDQUFBLElBQUEsRUFBQSxRQUFBLENBQUEsQ0FBUyxJQUFJLEtBQUssQ0FBQSxDQUFBO0FBRXZCLElBQUEsSUFBQSxDQUFLLHdCQUF3QixDQUFDLENBQUEsQ0FBQTtBQUU5QixJQUFJLElBQUEsQ0FBQyxJQUFLLENBQUEsS0FBQSxDQUFNLFNBQVcsRUFBQTtBQUN6QixNQUFBLElBQUEsQ0FBSyxRQUFTLENBQUEsRUFBRSxTQUFXLEVBQUEsSUFBQSxFQUFNLENBQUEsQ0FBQTtBQUFBLEtBQ25DO0FBQUEsR0FDRjtBQUFBLEVBRU8sZUFBZSxLQUFrQyxFQUFBO0FBQ3RELElBQUEsSUFBSSxDQUFDLFlBQUEsQ0FBQSxJQUFBLEVBQUssUUFBUyxDQUFBLENBQUEsR0FBQSxDQUFJLEtBQUssQ0FBRyxFQUFBO0FBQzdCLE1BQUEsT0FBQTtBQUFBLEtBQ0Y7QUFFQSxJQUFLLFlBQUEsQ0FBQSxJQUFBLEVBQUEsUUFBQSxDQUFBLENBQVMsT0FBTyxLQUFLLENBQUEsQ0FBQTtBQUUxQixJQUFBLElBQUEsQ0FBSyx3QkFBd0IsQ0FBRSxDQUFBLENBQUEsQ0FBQTtBQUUvQixJQUFJLElBQUEsWUFBQSxDQUFBLElBQUEsRUFBSyxRQUFTLENBQUEsQ0FBQSxJQUFBLEtBQVMsQ0FBRyxFQUFBO0FBQzVCLE1BQUEsSUFBQSxDQUFLLFFBQVMsQ0FBQSxFQUFFLFNBQVcsRUFBQSxLQUFBLEVBQU8sQ0FBQSxDQUFBO0FBQUEsS0FDcEM7QUFBQSxHQUNGO0FBQUEsRUFFUSx3QkFBd0IsR0FBYSxFQUFBO0FBM0UvQyxJQUFBLElBQUEsRUFBQSxDQUFBO0FBK0VJLElBQUMsTUFBZSxDQUFBLDBCQUFBLEdBQUEsQ0FBQSxDQUErQixFQUFlLEdBQUEsTUFBQSxDQUFBLDBCQUFBLEtBQWYsWUFBNkMsQ0FBSyxJQUFBLEdBQUEsQ0FBQTtBQUFBLEdBQ25HO0FBQUEsRUFFTyxTQUFZLEdBQUE7QUFsRnJCLElBQUEsSUFBQSxFQUFBLENBQUE7QUFtRkksSUFBQSxLQUFBLE1BQVcsS0FBUyxJQUFBLFlBQUEsQ0FBQSxJQUFBLEVBQUssUUFBUyxDQUFBLENBQUEsTUFBQSxFQUFVLEVBQUE7QUFDMUMsTUFBQSxDQUFBLEVBQUEsR0FBQSxLQUFBLENBQU0sTUFBTixLQUFBLElBQUEsR0FBQSxLQUFBLENBQUEsR0FBQSxFQUFBLENBQUEsSUFBQSxDQUFBLEtBQUEsQ0FBQSxDQUFBO0FBQUEsS0FDRjtBQUFBLEdBQ0Y7QUFDRixDQUFBO0FBL0NFLFFBQUEsR0FBQSxJQUFBLE9BQUEsRUFBQTs7OzsifQ==

package/dist/esm/src/behaviors/index.js

@@ -0,0 +1,5 @@
+export { ActWhenVariableChanged } from './ActWhenVariableChanged.js';
+export { CursorSync } from './CursorSync.js';
+export { SceneQueryController } from './SceneQueryController.js';
+export { LiveNowTimer } from './LiveNowTimer.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7In0=

package/dist/esm/src/components/EmbeddedScene.js

@@ -0,0 +1,59 @@
+import { css } from '@emotion/css';
+import { useStyles2 } from '@grafana/ui';
+import React from 'react';
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+import { setWindowGrafanaSceneContext } from '../utils/compatibility/setWindowGrafanaSceneContext.js';
+
+class EmbeddedScene extends SceneObjectBase {
+  constructor(state) {
+    super(state);
+    this.addActivationHandler(() => {
+      const unsetGlobalScene = setWindowGrafanaSceneContext(this);
+      return () => {
+        unsetGlobalScene();
+      };
+    });
+  }
+}
+EmbeddedScene.Component = EmbeddedSceneRenderer;
+function EmbeddedSceneRenderer({ model }) {
+  const { body, controls } = model.useState();
+  const styles = useStyles2(getStyles);
+  return /* @__PURE__ */ React.createElement("div", {
+    className: styles.container
+  }, controls && /* @__PURE__ */ React.createElement("div", {
+    className: styles.controls
+  }, controls.map((control) => /* @__PURE__ */ React.createElement(control.Component, {
+    key: control.state.key,
+    model: control
+  }))), /* @__PURE__ */ React.createElement("div", {
+    className: styles.body
+  }, /* @__PURE__ */ React.createElement(body.Component, {
+    model: body
+  })));
+}
+const getStyles = (theme) => {
+  return {
+    container: css({
+      flexGrow: 1,
+      display: "flex",
+      gap: theme.spacing(2),
+      minHeight: "100%",
+      flexDirection: "column"
+    }),
+    body: css({
+      flexGrow: 1,
+      display: "flex",
+      gap: theme.spacing(1)
+    }),
+    controls: css({
+      display: "flex",
+      gap: theme.spacing(2),
+      alignItems: "flex-end",
+      flexWrap: "wrap"
+    })
+  };
+};
+
+export { EmbeddedScene };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/components/NestedScene.js

@@ -0,0 +1,95 @@
+import { cx, css } from '@emotion/css';
+import React from 'react';
+import { useStyles2, ToolbarButton, Icon } from '@grafana/ui';
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+import { getSceneGridRowStyles } from './layout/grid/SceneGridRow.js';
+import { sceneGraph } from '../core/sceneGraph/index.js';
+
+class NestedScene extends SceneObjectBase {
+  constructor() {
+    super(...arguments);
+    this.onToggle = () => {
+      this.setState({
+        isCollapsed: !this.state.isCollapsed
+      });
+    };
+    this.onRemove = () => {
+      const parent = this.parent;
+      if (isSceneLayoutItem(parent)) {
+        parent.setState({
+          body: void 0
+        });
+      }
+    };
+  }
+}
+NestedScene.Component = NestedSceneRenderer;
+function NestedSceneRenderer({ model }) {
+  const { title, isCollapsed, canCollapse, canRemove, body, controls } = model.useState();
+  const gridRow = useStyles2(getSceneGridRowStyles);
+  const styles = useStyles2(getStyles);
+  const toolbarControls = (controls != null ? controls : []).map((action) => /* @__PURE__ */ React.createElement(action.Component, {
+    key: action.state.key,
+    model: action
+  }));
+  if (canRemove) {
+    toolbarControls.push(
+      /* @__PURE__ */ React.createElement(ToolbarButton, {
+        icon: "times",
+        variant: "default",
+        onClick: model.onRemove,
+        key: "remove-button",
+        "aria-label": "Remove scene"
+      })
+    );
+  }
+  return /* @__PURE__ */ React.createElement("div", {
+    className: styles.wrapper
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: cx(styles.row, isCollapsed && styles.rowCollapsed)
+  }, /* @__PURE__ */ React.createElement("button", {
+    onClick: model.onToggle,
+    className: gridRow.rowTitleButton,
+    "aria-label": isCollapsed ? "Expand scene" : "Collapse scene"
+  }, canCollapse && /* @__PURE__ */ React.createElement(Icon, {
+    name: isCollapsed ? "angle-right" : "angle-down"
+  }), /* @__PURE__ */ React.createElement("span", {
+    className: gridRow.rowTitle,
+    role: "heading"
+  }, sceneGraph.interpolate(model, title, void 0, "text"))), /* @__PURE__ */ React.createElement("div", {
+    className: styles.actions
+  }, toolbarControls)), !isCollapsed && /* @__PURE__ */ React.createElement(body.Component, {
+    model: body
+  }));
+}
+const getStyles = (theme) => ({
+  wrapper: css({
+    display: "flex",
+    flexDirection: "column",
+    flexGrow: 1,
+    gap: theme.spacing(1)
+  }),
+  row: css({
+    width: "100%",
+    display: "flex",
+    justifyContent: "space-between",
+    gap: theme.spacing(1)
+  }),
+  rowCollapsed: css({
+    borderBottom: `1px solid ${theme.colors.border.weak}`,
+    paddingBottom: theme.spacing(1)
+  }),
+  actions: css({
+    display: "flex",
+    alignItems: "center",
+    gap: theme.spacing(1),
+    justifyContent: "flex-end",
+    flexGrow: 1
+  })
+});
+function isSceneLayoutItem(x) {
+  return "body" in x.state;
+}
+
+export { NestedScene, NestedSceneRenderer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"NestedScene.js","sources":["../../../../src/components/NestedScene.tsx"],"sourcesContent":["import { css, cx } from '@emotion/css';\nimport React from 'react';\n\nimport { GrafanaTheme2 } from '@grafana/data';\nimport { Icon, ToolbarButton, useStyles2 } from '@grafana/ui';\n\nimport { SceneObjectBase } from '../core/SceneObjectBase';\nimport { SceneObject, SceneComponentProps, SceneLayout, SceneObjectState } from '../core/types';\nimport { getSceneGridRowStyles } from './layout/grid/SceneGridRow';\nimport { sceneGraph } from '../core/sceneGraph';\n\ninterface NestedSceneState extends SceneObjectState {\n  title: string;\n  isCollapsed?: boolean;\n  canCollapse?: boolean;\n  canRemove?: boolean;\n  body: SceneLayout;\n  controls?: SceneObject[];\n}\n\n/**\n * @internal\n * POC status, don't use this yet\n */\nexport class NestedScene extends SceneObjectBase<NestedSceneState> {\n  public static Component = NestedSceneRenderer;\n\n  public onToggle = () => {\n    this.setState({\n      isCollapsed: !this.state.isCollapsed,\n    });\n  };\n\n  /** Removes itself from its parent's children array */\n  public onRemove = () => {\n    const parent = this.parent!;\n\n    if (isSceneLayoutItem(parent)) {\n      parent.setState({\n        body: undefined,\n      });\n    }\n  };\n}\n\nexport function NestedSceneRenderer({ model }: SceneComponentProps<NestedScene>) {\n  const { title, isCollapsed, canCollapse, canRemove, body, controls } = model.useState();\n  const gridRow = useStyles2(getSceneGridRowStyles);\n  const styles = useStyles2(getStyles);\n\n  const toolbarControls = (controls ?? []).map((action) => <action.Component key={action.state.key} model={action} />);\n\n  if (canRemove) {\n    toolbarControls.push(\n      <ToolbarButton\n        icon=\"times\"\n        variant={'default'}\n        onClick={model.onRemove}\n        key=\"remove-button\"\n        aria-label=\"Remove scene\"\n      />\n    );\n  }\n\n  return (\n    <div className={styles.wrapper}>\n      <div className={cx(styles.row, isCollapsed && styles.rowCollapsed)}>\n        <button\n          onClick={model.onToggle}\n          className={gridRow.rowTitleButton}\n          aria-label={isCollapsed ? 'Expand scene' : 'Collapse scene'}\n        >\n          {canCollapse && <Icon name={isCollapsed ? 'angle-right' : 'angle-down'} />}\n          <span className={gridRow.rowTitle} role=\"heading\">\n            {sceneGraph.interpolate(model, title, undefined, 'text')}\n          </span>\n        </button>\n        <div className={styles.actions}>{toolbarControls}</div>\n      </div>\n      {!isCollapsed && <body.Component model={body} />}\n    </div>\n  );\n}\n\nconst getStyles = (theme: GrafanaTheme2) => ({\n  wrapper: css({\n    display: 'flex',\n    flexDirection: 'column',\n    flexGrow: 1,\n    gap: theme.spacing(1),\n  }),\n  row: css({\n    width: '100%',\n    display: 'flex',\n    justifyContent: 'space-between',\n    gap: theme.spacing(1),\n  }),\n  rowCollapsed: css({\n    borderBottom: `1px solid ${theme.colors.border.weak}`,\n    paddingBottom: theme.spacing(1),\n  }),\n  actions: css({\n    display: 'flex',\n    alignItems: 'center',\n    gap: theme.spacing(1),\n    justifyContent: 'flex-end',\n    flexGrow: 1,\n  }),\n});\n\nfunction isSceneLayoutItem(x: SceneObject): x is SceneObject<SceneObjectState & { body: SceneObject | undefined }> {\n  return 'body' in x.state;\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/src/components/SceneApp/SceneApp.js

@@ -0,0 +1,37 @@
+import React, { createContext } from 'react';
+import { Switch, Route } from 'react-router-dom';
+import { SceneObjectBase } from '../../core/SceneObjectBase.js';
+import { renderSceneComponentWithRouteProps } from './utils.js';
+
+class SceneApp extends SceneObjectBase {
+  enrichDataRequest() {
+    return {
+      app: this.state.name || "app"
+    };
+  }
+}
+SceneApp.Component = ({ model }) => {
+  const { pages } = model.useState();
+  return /* @__PURE__ */ React.createElement(SceneAppContext.Provider, {
+    value: model
+  }, /* @__PURE__ */ React.createElement(Switch, null, pages.map((page) => /* @__PURE__ */ React.createElement(Route, {
+    key: page.state.url,
+    exact: false,
+    path: page.state.url,
+    render: (props) => renderSceneComponentWithRouteProps(page, props)
+  }))));
+};
+const SceneAppContext = createContext(null);
+const sceneAppCache = /* @__PURE__ */ new Map();
+function useSceneApp(factory) {
+  const cachedApp = sceneAppCache.get(factory);
+  if (cachedApp) {
+    return cachedApp;
+  }
+  const newApp = factory();
+  sceneAppCache.set(factory, newApp);
+  return newApp;
+}
+
+export { SceneApp, SceneAppContext, useSceneApp };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/components/SceneApp/SceneAppPage.js

@@ -0,0 +1,176 @@
+import React from 'react';
+import { Route, Switch } from 'react-router-dom';
+import { SceneObjectBase } from '../../core/SceneObjectBase.js';
+import { isDataRequestEnricher } from '../../core/types.js';
+import { EmbeddedScene } from '../EmbeddedScene.js';
+import { SceneFlexLayout, SceneFlexItem } from '../layout/SceneFlexLayout.js';
+import { SceneReactObject } from '../SceneReactObject.js';
+import { SceneAppDrilldownViewRender, SceneAppPageView } from './SceneAppPageView.js';
+import { renderSceneComponentWithRouteProps } from './utils.js';
+
+class SceneAppPage extends SceneObjectBase {
+  constructor(state) {
+    super(state);
+    this._sceneCache = /* @__PURE__ */ new Map();
+    this._drilldownCache = /* @__PURE__ */ new Map();
+  }
+  initializeScene(scene) {
+    this.setState({ initializedScene: scene });
+  }
+  getScene(routeMatch) {
+    let scene = this._sceneCache.get(routeMatch.url);
+    if (scene) {
+      return scene;
+    }
+    if (!this.state.getScene) {
+      throw new Error("Missing getScene on SceneAppPage " + this.state.title);
+    }
+    scene = this.state.getScene(routeMatch);
+    this._sceneCache.set(routeMatch.url, scene);
+    return scene;
+  }
+  getDrilldownPage(drilldown, routeMatch) {
+    let page = this._drilldownCache.get(routeMatch.url);
+    if (page) {
+      return page;
+    }
+    page = drilldown.getPage(routeMatch, this);
+    this._drilldownCache.set(routeMatch.url, page);
+    return page;
+  }
+  enrichDataRequest(source) {
+    if (this.state.getParentPage) {
+      return this.state.getParentPage().enrichDataRequest(source);
+    }
+    if (!this.parent) {
+      return null;
+    }
+    const root = this.getRoot();
+    if (isDataRequestEnricher(root)) {
+      return root.enrichDataRequest(source);
+    }
+    return null;
+  }
+}
+SceneAppPage.Component = SceneAppPageRenderer;
+function SceneAppPageRenderer({ model, routeProps }) {
+  var _a, _b;
+  const { tabs, drilldowns } = model.useState();
+  const routes = [];
+  if (tabs && tabs.length > 0) {
+    for (let tabIndex = 0; tabIndex < tabs.length; tabIndex++) {
+      const tab = tabs[tabIndex];
+      if (tabIndex === 0) {
+        routes.push(
+          /* @__PURE__ */ React.createElement(Route, {
+            exact: true,
+            key: model.state.url,
+            path: (_a = model.state.routePath) != null ? _a : model.state.url,
+            render: (props) => renderSceneComponentWithRouteProps(tab, props)
+          })
+        );
+      }
+      routes.push(
+        /* @__PURE__ */ React.createElement(Route, {
+          exact: true,
+          key: tab.state.url,
+          path: (_b = tab.state.routePath) != null ? _b : tab.state.url,
+          render: (props) => renderSceneComponentWithRouteProps(tab, props)
+        })
+      );
+      if (tab.state.drilldowns) {
+        for (const drilldown of tab.state.drilldowns) {
+          routes.push(
+            /* @__PURE__ */ React.createElement(Route, {
+              exact: false,
+              key: drilldown.routePath,
+              path: drilldown.routePath,
+              render: (props) => /* @__PURE__ */ React.createElement(SceneAppDrilldownViewRender, {
+                drilldown,
+                parent: tab,
+                routeProps: props
+              })
+            })
+          );
+        }
+      }
+    }
+  }
+  if (drilldowns) {
+    for (const drilldown of drilldowns) {
+      routes.push(
+        /* @__PURE__ */ React.createElement(Route, {
+          key: drilldown.routePath,
+          exact: false,
+          path: drilldown.routePath,
+          render: (props) => /* @__PURE__ */ React.createElement(SceneAppDrilldownViewRender, {
+            drilldown,
+            parent: model,
+            routeProps: props
+          })
+        })
+      );
+    }
+  }
+  if (!tabs && isCurrentPageRouteMatch(model, routeProps.match)) {
+    return /* @__PURE__ */ React.createElement(SceneAppPageView, {
+      page: model,
+      routeProps
+    });
+  }
+  routes.push(getFallbackRoute(model, routeProps));
+  return /* @__PURE__ */ React.createElement(Switch, null, routes);
+}
+function getFallbackRoute(page, routeProps) {
+  return /* @__PURE__ */ React.createElement(Route, {
+    key: "fallback route",
+    render: (props) => {
+      var _a, _b, _c;
+      const fallbackPage = (_c = (_b = (_a = page.state).getFallbackPage) == null ? void 0 : _b.call(_a)) != null ? _c : getDefaultFallbackPage();
+      return /* @__PURE__ */ React.createElement(SceneAppPageView, {
+        page: fallbackPage,
+        routeProps
+      });
+    }
+  });
+}
+function isCurrentPageRouteMatch(page, match) {
+  if (!match.isExact) {
+    return false;
+  }
+  if (match.url === page.state.url) {
+    return true;
+  }
+  if (page.parent instanceof SceneAppPage && page.parent.state.tabs[0] === page && page.parent.state.url === match.url) {
+    return true;
+  }
+  return false;
+}
+function getDefaultFallbackPage() {
+  return new SceneAppPage({
+    url: "",
+    title: "Not found",
+    subTitle: "The url did not match any page",
+    getScene: () => {
+      return new EmbeddedScene({
+        body: new SceneFlexLayout({
+          direction: "column",
+          children: [
+            new SceneFlexItem({
+              body: new SceneReactObject({
+                component: () => {
+                  return /* @__PURE__ */ React.createElement("div", {
+                    "data-testid": "default-fallback-content"
+                  }, "If you found your way here using a link then there might be a bug in this application.");
+                }
+              })
+            })
+          ]
+        })
+      });
+    }
+  });
+}
+
+export { SceneAppPage };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"SceneAppPage.js","sources":["../../../../../src/components/SceneApp/SceneAppPage.tsx"],"sourcesContent":["import React from 'react';\nimport { Route, RouteComponentProps, Switch } from 'react-router-dom';\nimport { SceneObjectBase } from '../../core/SceneObjectBase';\nimport { SceneComponentProps, SceneObject, isDataRequestEnricher } from '../../core/types';\nimport { EmbeddedScene } from '../EmbeddedScene';\nimport { SceneFlexItem, SceneFlexLayout } from '../layout/SceneFlexLayout';\nimport { SceneReactObject } from '../SceneReactObject';\nimport { SceneAppDrilldownViewRender, SceneAppPageView } from './SceneAppPageView';\nimport { SceneAppDrilldownView, SceneAppPageLike, SceneAppPageState, SceneRouteMatch } from './types';\nimport { renderSceneComponentWithRouteProps } from './utils';\n\n/**\n * Responsible for page's drilldown & tabs routing\n */\nexport class SceneAppPage extends SceneObjectBase<SceneAppPageState> implements SceneAppPageLike {\n  public static Component = SceneAppPageRenderer;\n  private _sceneCache = new Map<string, EmbeddedScene>();\n  private _drilldownCache = new Map<string, SceneAppPageLike>();\n\n  public constructor(state: SceneAppPageState) {\n    super(state);\n  }\n\n  public initializeScene(scene: EmbeddedScene) {\n    this.setState({ initializedScene: scene });\n  }\n\n  public getScene(routeMatch: SceneRouteMatch): EmbeddedScene {\n    let scene = this._sceneCache.get(routeMatch.url);\n\n    if (scene) {\n      return scene;\n    }\n\n    if (!this.state.getScene) {\n      throw new Error('Missing getScene on SceneAppPage ' + this.state.title);\n    }\n\n    scene = this.state.getScene(routeMatch);\n    this._sceneCache.set(routeMatch.url, scene);\n\n    return scene;\n  }\n\n  public getDrilldownPage(drilldown: SceneAppDrilldownView, routeMatch: SceneRouteMatch<{}>): SceneAppPageLike {\n    let page = this._drilldownCache.get(routeMatch!.url);\n    if (page) {\n      return page;\n    }\n\n    page = drilldown.getPage(routeMatch, this);\n    this._drilldownCache.set(routeMatch!.url, page);\n\n    return page;\n  }\n\n  public enrichDataRequest(source: SceneObject) {\n    if (this.state.getParentPage) {\n      return this.state.getParentPage().enrichDataRequest(source);\n    }\n\n    if (!this.parent) {\n      return null;\n    }\n\n    const root = this.getRoot();\n\n    if (isDataRequestEnricher(root)) {\n      return root.enrichDataRequest(source);\n    }\n\n    return null;\n  }\n}\n\nexport interface SceneAppPageRendererProps extends SceneComponentProps<SceneAppPage> {\n  routeProps: RouteComponentProps;\n}\n\nfunction SceneAppPageRenderer({ model, routeProps }: SceneAppPageRendererProps) {\n  const { tabs, drilldowns } = model.useState();\n  const routes: React.ReactNode[] = [];\n\n  if (tabs && tabs.length > 0) {\n    for (let tabIndex = 0; tabIndex < tabs.length; tabIndex++) {\n      const tab = tabs[tabIndex];\n\n      // Add first tab as a default route, this makes it possible for the first tab to render with the url of the parent page\n      if (tabIndex === 0) {\n        routes.push(\n          <Route\n            exact={true}\n            key={model.state.url}\n            path={model.state.routePath ?? model.state.url}\n            render={(props) => renderSceneComponentWithRouteProps(tab, props)}\n          ></Route>\n        );\n      }\n\n      routes.push(\n        <Route\n          exact={true}\n          key={tab.state.url}\n          path={tab.state.routePath ?? tab.state.url}\n          render={(props) => renderSceneComponentWithRouteProps(tab, props)}\n        ></Route>\n      );\n\n      if (tab.state.drilldowns) {\n        for (const drilldown of tab.state.drilldowns) {\n          routes.push(\n            <Route\n              exact={false}\n              key={drilldown.routePath}\n              path={drilldown.routePath}\n              render={(props) => <SceneAppDrilldownViewRender drilldown={drilldown} parent={tab} routeProps={props} />}\n            ></Route>\n          );\n        }\n      }\n    }\n  }\n\n  if (drilldowns) {\n    for (const drilldown of drilldowns) {\n      routes.push(\n        <Route\n          key={drilldown.routePath}\n          exact={false}\n          path={drilldown.routePath}\n          render={(props) => <SceneAppDrilldownViewRender drilldown={drilldown} parent={model} routeProps={props} />}\n        ></Route>\n      );\n    }\n  }\n\n  if (!tabs && isCurrentPageRouteMatch(model, routeProps.match)) {\n    return <SceneAppPageView page={model} routeProps={routeProps} />;\n  }\n\n  routes.push(getFallbackRoute(model, routeProps));\n\n  return <Switch>{routes}</Switch>;\n}\n\nfunction getFallbackRoute(page: SceneAppPage, routeProps: RouteComponentProps) {\n  return (\n    <Route\n      key={'fallback route'}\n      render={(props) => {\n        const fallbackPage = page.state.getFallbackPage?.() ?? getDefaultFallbackPage();\n        return <SceneAppPageView page={fallbackPage} routeProps={routeProps} />;\n      }}\n    ></Route>\n  );\n}\n\nfunction isCurrentPageRouteMatch(page: SceneAppPage, match: SceneRouteMatch) {\n  if (!match.isExact) {\n    return false;\n  }\n\n  // current page matches the route url\n  if (match.url === page.state.url) {\n    return true;\n  }\n\n  // check if we are a tab and the first tab, then we should also render on the parent url\n  if (\n    page.parent instanceof SceneAppPage &&\n    page.parent.state.tabs![0] === page &&\n    page.parent.state.url === match.url\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction getDefaultFallbackPage() {\n  return new SceneAppPage({\n    url: '',\n    title: 'Not found',\n    subTitle: 'The url did not match any page',\n    getScene: () => {\n      return new EmbeddedScene({\n        body: new SceneFlexLayout({\n          direction: 'column',\n          children: [\n            new SceneFlexItem({\n              body: new SceneReactObject({\n                component: () => {\n                  return (\n                    <div data-testid=\"default-fallback-content\">\n                      If you found your way here using a link then there might be a bug in this application.\n                    </div>\n                  );\n                },\n              }),\n            }),\n          ],\n        }),\n      });\n    },\n  });\n}\n"],"names":[],"mappings":"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"}