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

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

@@ -0,0 +1,104 @@
+import { PluginPage } from '@grafana/runtime';
+import React, { useContext, useLayoutEffect, useEffect } from 'react';
+import { SceneDebugger } from '../SceneDebugger/SceneDebugger.js';
+import { SceneAppPage } from './SceneAppPage.js';
+import { useAppQueryParams, getUrlWithAppState, renderSceneComponentWithRouteProps } from './utils.js';
+import { useUrlSync } from '../../services/useUrlSync.js';
+import { SceneAppContext } from './SceneApp.js';
+import { useLocationServiceSafe } from '../../utils/utils.js';
+
+function SceneAppPageView({ page, routeProps }) {
+  const containerPage = getParentPageIfTab(page);
+  const containerState = containerPage.useState();
+  const params = useAppQueryParams();
+  const scene = page.getScene(routeProps.match);
+  const appContext = useContext(SceneAppContext);
+  const isInitialized = containerState.initializedScene === scene;
+  const { layout } = page.state;
+  const locationService = useLocationServiceSafe();
+  useLayoutEffect(() => {
+    if (!isInitialized) {
+      containerPage.initializeScene(scene);
+    }
+  }, [scene, containerPage, isInitialized]);
+  useEffect(() => {
+    return () => containerPage.setState({ initializedScene: void 0 });
+  }, [containerPage]);
+  const urlSyncInitialized = useUrlSync(containerPage, appContext == null ? void 0 : appContext.state.urlSyncOptions);
+  if (!isInitialized && !urlSyncInitialized) {
+    return null;
+  }
+  const pageNav = {
+    text: containerState.title,
+    img: containerState.titleImg,
+    icon: containerState.titleIcon,
+    url: getUrlWithAppState(containerState.url, locationService.getSearchObject(), containerState.preserveUrlKeys),
+    hideFromBreadcrumbs: containerState.hideFromBreadcrumbs,
+    parentItem: getParentBreadcrumbs(
+      containerState.getParentPage ? containerState.getParentPage() : containerPage.parent,
+      params,
+      locationService.getSearchObject()
+    )
+  };
+  if (containerState.tabs) {
+    pageNav.children = containerState.tabs.map((tab) => {
+      return {
+        text: tab.state.title,
+        icon: tab.state.titleIcon,
+        tabSuffix: tab.state.tabSuffix,
+        active: page === tab,
+        url: getUrlWithAppState(tab.state.url, locationService.getSearchObject(), tab.state.preserveUrlKeys),
+        parentItem: pageNav
+      };
+    });
+  }
+  let pageActions = [];
+  if (containerState.controls) {
+    pageActions = containerState.controls.map((control) => /* @__PURE__ */ React.createElement(control.Component, {
+      model: control,
+      key: control.state.key
+    }));
+  }
+  if (params["scene-debugger"]) {
+    pageActions.push(/* @__PURE__ */ React.createElement(SceneDebugger, {
+      scene: containerPage,
+      key: "scene-debugger"
+    }));
+  }
+  return /* @__PURE__ */ React.createElement(PluginPage, {
+    layout,
+    pageNav,
+    actions: pageActions,
+    renderTitle: containerState.renderTitle,
+    subTitle: containerState.subTitle
+  }, /* @__PURE__ */ React.createElement(scene.Component, {
+    model: scene
+  }));
+}
+function getParentPageIfTab(page) {
+  if (page.parent instanceof SceneAppPage) {
+    return page.parent;
+  }
+  return page;
+}
+function getParentBreadcrumbs(parent, params, searchObject) {
+  if (parent instanceof SceneAppPage) {
+    return {
+      text: parent.state.title,
+      url: getUrlWithAppState(parent.state.url, searchObject, parent.state.preserveUrlKeys),
+      hideFromBreadcrumbs: parent.state.hideFromBreadcrumbs,
+      parentItem: getParentBreadcrumbs(
+        parent.state.getParentPage ? parent.state.getParentPage() : parent.parent,
+        params,
+        searchObject
+      )
+    };
+  }
+  return void 0;
+}
+function SceneAppDrilldownViewRender({ drilldown, parent, routeProps }) {
+  return renderSceneComponentWithRouteProps(parent.getDrilldownPage(drilldown, routeProps.match), routeProps);
+}
+
+export { SceneAppDrilldownViewRender, SceneAppPageView };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"SceneAppPageView.js","sources":["../../../../../src/components/SceneApp/SceneAppPageView.tsx"],"sourcesContent":["import { NavModelItem, UrlQueryMap } from '@grafana/data';\nimport { PluginPage } from '@grafana/runtime';\nimport React, { useContext, useEffect, useLayoutEffect } from 'react';\n\nimport { RouteComponentProps } from 'react-router-dom';\nimport { SceneObject } from '../../core/types';\nimport { SceneDebugger } from '../SceneDebugger/SceneDebugger';\nimport { SceneAppPage } from './SceneAppPage';\nimport { SceneAppDrilldownView, SceneAppPageLike } from './types';\nimport { getUrlWithAppState, renderSceneComponentWithRouteProps, useAppQueryParams } from './utils';\nimport { useUrlSync } from '../../services/useUrlSync';\nimport { SceneAppContext } from './SceneApp';\nimport { useLocationServiceSafe } from '../../utils/utils';\n\nexport interface Props {\n  page: SceneAppPageLike;\n  routeProps: RouteComponentProps;\n}\n\nexport function SceneAppPageView({ page, routeProps }: Props) {\n  const containerPage = getParentPageIfTab(page);\n  const containerState = containerPage.useState();\n  const params = useAppQueryParams();\n  const scene = page.getScene(routeProps.match);\n  const appContext = useContext(SceneAppContext);\n  const isInitialized = containerState.initializedScene === scene;\n  const { layout } = page.state;\n  const locationService = useLocationServiceSafe();\n\n  useLayoutEffect(() => {\n    // Before rendering scene components, we are making sure the URL sync is enabled for.\n    if (!isInitialized) {\n      containerPage.initializeScene(scene);\n    }\n  }, [scene, containerPage, isInitialized]);\n\n  useEffect(() => {\n    // Clear initializedScene when unmounting\n    return () => containerPage.setState({ initializedScene: undefined });\n  }, [containerPage]);\n\n  const urlSyncInitialized = useUrlSync(containerPage, appContext?.state.urlSyncOptions);\n\n  if (!isInitialized && !urlSyncInitialized) {\n    return null;\n  }\n\n  const pageNav: NavModelItem = {\n    text: containerState.title,\n    img: containerState.titleImg,\n    icon: containerState.titleIcon,\n    url: getUrlWithAppState(containerState.url, locationService.getSearchObject(), containerState.preserveUrlKeys),\n    hideFromBreadcrumbs: containerState.hideFromBreadcrumbs,\n    parentItem: getParentBreadcrumbs(\n      containerState.getParentPage ? containerState.getParentPage() : containerPage.parent,\n      params,\n      locationService.getSearchObject()\n    ),\n  };\n\n  if (containerState.tabs) {\n    pageNav.children = containerState.tabs.map((tab) => {\n      return {\n        text: tab.state.title,\n        icon: tab.state.titleIcon,\n        tabSuffix: tab.state.tabSuffix,\n        active: page === tab,\n        url: getUrlWithAppState(tab.state.url, locationService.getSearchObject(), tab.state.preserveUrlKeys),\n        parentItem: pageNav,\n      };\n    });\n  }\n\n  let pageActions: React.ReactNode[] = [];\n  if (containerState.controls) {\n    pageActions = containerState.controls.map((control) => (\n      <control.Component model={control} key={control.state.key} />\n    ));\n  }\n\n  if (params['scene-debugger']) {\n    pageActions.push(<SceneDebugger scene={containerPage} key={'scene-debugger'} />);\n  }\n\n  return (\n    <PluginPage\n      layout={layout}\n      pageNav={pageNav}\n      actions={pageActions}\n      renderTitle={containerState.renderTitle}\n      subTitle={containerState.subTitle}\n    >\n      <scene.Component model={scene} />\n    </PluginPage>\n  );\n}\n\n/**\n * For pages that are \"tabs\" this will return the parent page\n */\nfunction getParentPageIfTab(page: SceneAppPageLike) {\n  if (page.parent instanceof SceneAppPage) {\n    return page.parent;\n  }\n\n  return page;\n}\n\nfunction getParentBreadcrumbs(\n  parent: SceneObject | undefined,\n  params: UrlQueryMap,\n  searchObject: UrlQueryMap\n): NavModelItem | undefined {\n  if (parent instanceof SceneAppPage) {\n    return {\n      text: parent.state.title,\n      url: getUrlWithAppState(parent.state.url, searchObject, parent.state.preserveUrlKeys),\n      hideFromBreadcrumbs: parent.state.hideFromBreadcrumbs,\n      parentItem: getParentBreadcrumbs(\n        parent.state.getParentPage ? parent.state.getParentPage() : parent.parent,\n        params,\n        searchObject\n      ),\n    };\n  }\n\n  return undefined;\n}\n\nexport interface SceneAppDrilldownViewRenderProps {\n  drilldown: SceneAppDrilldownView;\n  parent: SceneAppPageLike;\n  routeProps: RouteComponentProps;\n}\n\nexport function SceneAppDrilldownViewRender({ drilldown, parent, routeProps }: SceneAppDrilldownViewRenderProps) {\n  return renderSceneComponentWithRouteProps(parent.getDrilldownPage(drilldown, routeProps.match), routeProps);\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,42 @@
+import React from 'react';
+import { useLocation } from 'react-router-dom';
+import { urlUtil, locationUtil } from '@grafana/data';
+import { locationSearchToObject } from '@grafana/runtime';
+
+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 useAppQueryParams() {
+  const location = useLocation();
+  return locationSearchToObject(location.search || "");
+}
+function getUrlWithAppState(path, searchObject, preserveParams) {
+  const paramsCopy = __spreadValues({}, searchObject);
+  if (preserveParams) {
+    for (const key of Object.keys(paramsCopy)) {
+      if (!preserveParams.includes(key)) {
+        delete paramsCopy[key];
+      }
+    }
+  }
+  return urlUtil.renderUrl(locationUtil.assureBaseUrl(path), paramsCopy);
+}
+function renderSceneComponentWithRouteProps(sceneObject, routeProps) {
+  return React.createElement(sceneObject.Component, { model: sceneObject, routeProps });
+}
+
+export { getUrlWithAppState, renderSceneComponentWithRouteProps, useAppQueryParams };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,41 @@
+import React from 'react';
+import { LoadingState } from '@grafana/data';
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+import { sceneGraph } from '../core/sceneGraph/index.js';
+
+class SceneByFrameRepeater extends SceneObjectBase {
+  constructor(state) {
+    super(state);
+    this.addActivationHandler(() => {
+      const dataProvider = sceneGraph.getData(this);
+      this._subs.add(
+        dataProvider.subscribeToState((data) => {
+          var _a;
+          if (((_a = data.data) == null ? void 0 : _a.state) === LoadingState.Done) {
+            this.performRepeat(data.data);
+          }
+        })
+      );
+      if (dataProvider.state.data) {
+        this.performRepeat(dataProvider.state.data);
+      }
+    });
+  }
+  performRepeat(data) {
+    const newChildren = [];
+    for (let seriesIndex = 0; seriesIndex < data.series.length; seriesIndex++) {
+      const layoutChild = this.state.getLayoutChild(data, data.series[seriesIndex], seriesIndex);
+      newChildren.push(layoutChild);
+    }
+    this.state.body.setState({ children: newChildren });
+  }
+}
+SceneByFrameRepeater.Component = ({ model }) => {
+  const { body } = model.useState();
+  return /* @__PURE__ */ React.createElement(body.Component, {
+    model: body
+  });
+};
+
+export { SceneByFrameRepeater };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,55 @@
+import React from 'react';
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+import { sceneGraph } from '../core/sceneGraph/index.js';
+import { VariableDependencyConfig } from '../variables/VariableDependencyConfig.js';
+import { MultiValueVariable } from '../variables/variants/MultiValueVariable.js';
+
+class SceneByVariableRepeater extends SceneObjectBase {
+  constructor(state) {
+    super(state);
+    this._variableDependency = new VariableDependencyConfig(
+      this,
+      {
+        variableNames: [this.state.variableName],
+        onVariableUpdateCompleted: () => this.performRepeat()
+      }
+    );
+    this.addActivationHandler(() => this.performRepeat());
+  }
+  performRepeat() {
+    if (this._variableDependency.hasDependencyInLoadingState()) {
+      return;
+    }
+    const variable = sceneGraph.lookupVariable(this.state.variableName, this);
+    if (!(variable instanceof MultiValueVariable)) {
+      console.error("SceneByVariableRepeater: variable is not a MultiValueVariable");
+      return;
+    }
+    const values = getMultiVariableValues(variable);
+    const newChildren = [];
+    for (const option of values) {
+      const layoutChild = this.state.getLayoutChild(option);
+      newChildren.push(layoutChild);
+    }
+    this.state.body.setState({ children: newChildren });
+  }
+}
+SceneByVariableRepeater.Component = ({ model }) => {
+  const { body } = model.useState();
+  return /* @__PURE__ */ React.createElement(body.Component, {
+    model: body
+  });
+};
+function getMultiVariableValues(variable) {
+  const { value, text, options } = variable.state;
+  if (variable.hasAllValue()) {
+    return options;
+  }
+  if (Array.isArray(value) && Array.isArray(text)) {
+    return value.map((v, i) => ({ value: v, label: text[i] }));
+  }
+  return [{ value, label: text }];
+}
+
+export { SceneByVariableRepeater, getMultiVariableValues };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,32 @@
+import React from 'react';
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+import { sceneGraph } from '../core/sceneGraph/index.js';
+import { VariableDependencyConfig } from '../variables/VariableDependencyConfig.js';
+import { useTheme2 } from '@grafana/ui';
+import { css } from '@emotion/css';
+
+class SceneCanvasText extends SceneObjectBase {
+  constructor() {
+    super(...arguments);
+    this._variableDependency = new VariableDependencyConfig(this, { statePaths: ["text"] });
+  }
+}
+SceneCanvasText.Component = ({ model }) => {
+  const { text, fontSize = 20, align = "left", key, spacing } = model.useState();
+  const theme = useTheme2();
+  const style = css({
+    fontSize,
+    display: "flex",
+    flexGrow: 1,
+    alignItems: "center",
+    padding: spacing ? theme.spacing(spacing, 0) : void 0,
+    justifyContent: align
+  });
+  return /* @__PURE__ */ React.createElement("div", {
+    className: style,
+    "data-testid": key
+  }, sceneGraph.interpolate(model, text));
+};
+
+export { SceneCanvasText };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+
+class SceneControlsSpacer extends SceneObjectBase {
+  constructor() {
+    super({});
+    this._renderBeforeActivation = true;
+  }
+}
+SceneControlsSpacer.Component = (_props) => {
+  return /* @__PURE__ */ React.createElement("div", {
+    style: { flexGrow: 1 }
+  });
+};
+
+export { SceneControlsSpacer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2NlbmVDb250cm9sc1NwYWNlci5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NvbXBvbmVudHMvU2NlbmVDb250cm9sc1NwYWNlci50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcblxuaW1wb3J0IHsgU2NlbmVPYmplY3RCYXNlIH0gZnJvbSAnLi4vY29yZS9TY2VuZU9iamVjdEJhc2UnO1xuaW1wb3J0IHsgU2NlbmVDb21wb25lbnRQcm9wcyB9IGZyb20gJy4uL2NvcmUvdHlwZXMnO1xuXG5leHBvcnQgY2xhc3MgU2NlbmVDb250cm9sc1NwYWNlciBleHRlbmRzIFNjZW5lT2JqZWN0QmFzZSB7XG4gIHB1YmxpYyBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcih7fSk7XG5cbiAgICB0aGlzLl9yZW5kZXJCZWZvcmVBY3RpdmF0aW9uID0gdHJ1ZTtcbiAgfVxuXG4gIHB1YmxpYyBzdGF0aWMgQ29tcG9uZW50ID0gKF9wcm9wczogU2NlbmVDb21wb25lbnRQcm9wczxTY2VuZUNvbnRyb2xzU3BhY2VyPikgPT4ge1xuICAgIHJldHVybiA8ZGl2IHN0eWxlPXt7IGZsZXhHcm93OiAxIH19IC8+O1xuICB9O1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUtPLE1BQU0sNEJBQTRCLGVBQWdCLENBQUE7QUFBQSxFQUNoRCxXQUFjLEdBQUE7QUFDbkIsSUFBQSxLQUFBLENBQU0sRUFBRSxDQUFBLENBQUE7QUFFUixJQUFBLElBQUEsQ0FBSyx1QkFBMEIsR0FBQSxJQUFBLENBQUE7QUFBQSxHQUNqQztBQUtGLENBQUE7QUFWYSxtQkFPRyxDQUFBLFNBQUEsR0FBWSxDQUFDLE1BQXFELEtBQUE7QUFDOUUsRUFBQSx1QkFBUSxLQUFBLENBQUEsYUFBQSxDQUFBLEtBQUEsRUFBQTtBQUFBLElBQUksS0FBQSxFQUFPLEVBQUUsUUFBQSxFQUFVLENBQUUsRUFBQTtBQUFBLEdBQUcsQ0FBQSxDQUFBO0FBQ3RDLENBQUE7Ozs7In0=

package/dist/esm/src/components/SceneDebugger/DebugDetails.js

@@ -0,0 +1,82 @@
+import { css } from '@emotion/css';
+import { useStyles2, JSONFormatter, Input } from '@grafana/ui';
+import { isPlainObject, isArray } from 'lodash';
+import React from 'react';
+import { isSceneObject } from '../../core/types.js';
+
+function DebugDetails({ node }) {
+  const state = node.useState();
+  const styles = useStyles2(getStyles);
+  return /* @__PURE__ */ React.createElement("div", {
+    className: styles.container
+  }, Object.keys(state).map((key) => /* @__PURE__ */ React.createElement("div", {
+    className: styles.row,
+    key
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: styles.keyName
+  }, key), /* @__PURE__ */ React.createElement("div", {
+    className: styles.value
+  }, renderValue(key, state[key], node)))));
+}
+function renderValue(key, value, node) {
+  if (value === null) {
+    return "null";
+  }
+  switch (typeof value) {
+    case "number":
+      return /* @__PURE__ */ React.createElement(Input, {
+        type: "number",
+        defaultValue: value,
+        onBlur: (evt) => node.setState({ [key]: evt.currentTarget.valueAsNumber })
+      });
+    case "string":
+      return /* @__PURE__ */ React.createElement(Input, {
+        type: "text",
+        defaultValue: value,
+        onBlur: (evt) => node.setState({ [key]: evt.currentTarget.value })
+      });
+    case "object":
+      if (isSceneObject(value)) {
+        return value.constructor.name;
+      }
+      if (isPlainObject(value) || isArray(value)) {
+        return /* @__PURE__ */ React.createElement(JSONFormatter, {
+          json: value,
+          open: 0
+        });
+      }
+      return String(value);
+    default:
+      return typeof value;
+  }
+}
+function getStyles(theme) {
+  return {
+    container: css({
+      flexGrow: 1,
+      display: "flex",
+      gap: theme.spacing(0.5),
+      flexDirection: "column"
+    }),
+    row: css({
+      display: "flex",
+      gap: theme.spacing(2)
+    }),
+    keyName: css({
+      display: "flex",
+      flexGrow: "0",
+      width: 120,
+      alignItems: "center",
+      height: theme.spacing(theme.components.height.md)
+    }),
+    value: css({
+      flexGrow: 1,
+      minHeight: theme.spacing(theme.components.height.md),
+      display: "flex",
+      alignItems: "center"
+    })
+  };
+}
+
+export { DebugDetails };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/components/SceneDebugger/DebugTreeNode.js

@@ -0,0 +1,72 @@
+import { cx, css } from '@emotion/css';
+import { useStyles2 } from '@grafana/ui';
+import React from 'react';
+
+function DebugTreeNode({ node, selectedObject, onSelect }) {
+  const styles = useStyles2(getStyles);
+  const children = [];
+  const isSelected = node === selectedObject;
+  node.forEachChild((child) => {
+    children.push(
+      /* @__PURE__ */ React.createElement(DebugTreeNode, {
+        node: child,
+        key: child.state.key,
+        selectedObject,
+        onSelect
+      })
+    );
+  });
+  return /* @__PURE__ */ React.createElement("div", {
+    className: styles.container
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: cx(styles.name, isSelected && styles.selected),
+    onClick: () => onSelect(node)
+  }, node.constructor.name), /* @__PURE__ */ React.createElement("div", {
+    className: styles.children
+  }, children));
+}
+function getStyles(theme) {
+  return {
+    container: css({
+      flexGrow: 1,
+      display: "flex",
+      gap: theme.spacing(0.5),
+      flexDirection: "column"
+    }),
+    name: css({
+      flexGrow: 1,
+      display: "flex",
+      gap: theme.spacing(1),
+      fontSize: theme.typography.bodySmall.fontSize,
+      cursor: "pointer",
+      padding: theme.spacing(0, 1),
+      borderRadius: theme.shape.borderRadius(2),
+      position: "relative",
+      "&:hover": {
+        background: theme.colors.background.secondary
+      }
+    }),
+    selected: css({
+      "&::before": {
+        display: "block",
+        content: "' '",
+        position: "absolute",
+        left: 0,
+        width: 4,
+        bottom: 2,
+        top: 2,
+        borderRadius: theme.shape.radius.default,
+        backgroundImage: theme.colors.gradients.brandVertical
+      }
+    }),
+    children: css({
+      flexGrow: 1,
+      display: "flex",
+      flexDirection: "column",
+      paddingLeft: theme.spacing(1)
+    })
+  };
+}
+
+export { DebugTreeNode };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,77 @@
+import { css } from '@emotion/css';
+import { useStyles2, ToolbarButton, Drawer, CustomScrollbar } from '@grafana/ui';
+import React, { useState } from 'react';
+import { DebugDetails } from './DebugDetails.js';
+import { DebugTreeNode } from './DebugTreeNode.js';
+
+function SceneDebugger({ scene }) {
+  const styles = useStyles2(getStyles);
+  const [isOpen, setIsOpen] = useState(false);
+  const [selectedObject, setSelectedObject] = useState();
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ToolbarButton, {
+    variant: "canvas",
+    icon: "bug",
+    onClick: () => setIsOpen(true)
+  }), isOpen && /* @__PURE__ */ React.createElement(Drawer, {
+    title: "Scene debugger",
+    onClose: () => setIsOpen(false),
+    size: "lg"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: styles.panes
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: styles.pane1
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: styles.paneHeading
+  }, "Scene graph"), /* @__PURE__ */ React.createElement(CustomScrollbar, {
+    autoHeightMin: "100%"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: styles.treeWrapper
+  }, /* @__PURE__ */ React.createElement(DebugTreeNode, {
+    node: scene,
+    selectedObject,
+    onSelect: setSelectedObject
+  })))), /* @__PURE__ */ React.createElement("div", {
+    className: styles.pane2
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: styles.paneHeading
+  }, "Object details"), selectedObject && /* @__PURE__ */ React.createElement(DebugDetails, {
+    node: selectedObject
+  })))));
+}
+function getStyles(theme) {
+  return {
+    panes: css({
+      flexGrow: 1,
+      display: "flex",
+      height: "100%",
+      flexDirection: "row",
+      marginTop: theme.spacing(-2)
+    }),
+    pane1: css({
+      flexGrow: 0,
+      display: "flex",
+      height: "100%",
+      flexDirection: "column",
+      borderRight: `1px solid ${theme.colors.border.weak}`
+    }),
+    pane2: css({
+      flexGrow: 1,
+      display: "flex",
+      minHeight: "100%",
+      flexDirection: "column",
+      paddingLeft: theme.spacing(2)
+    }),
+    treeWrapper: css({
+      paddingRight: theme.spacing(2),
+      height: "100%",
+      marginLeft: theme.spacing(-1)
+    }),
+    paneHeading: css({
+      padding: theme.spacing(1, 0),
+      fontWeight: theme.typography.fontWeightMedium
+    })
+  };
+}
+
+export { SceneDebugger };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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