@grafana/scenes 6.7.0 → 6.8.0

package/dist/esm/dist/esm/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/dist/esm/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,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

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

package/dist/esm/dist/esm/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,{"version":3,"file":"DebugTreeNode.js","sources":["../../../../components/SceneDebugger/DebugTreeNode.js"],"sourcesContent":["import { cx, css } from '@emotion/css';\nimport { useStyles2 } from '@grafana/ui';\nimport React from 'react';\n\nfunction DebugTreeNode({ node, selectedObject, onSelect }) {\n  const styles = useStyles2(getStyles);\n  const children = [];\n  const isSelected = node === selectedObject;\n  node.forEachChild((child) => {\n    children.push(\n      /* @__PURE__ */ React.createElement(DebugTreeNode, {\n        node: child,\n        key: child.state.key,\n        selectedObject,\n        onSelect\n      })\n    );\n  });\n  return /* @__PURE__ */ React.createElement(\"div\", {\n    className: styles.container\n  }, /* @__PURE__ */ React.createElement(\"div\", {\n    className: cx(styles.name, isSelected && styles.selected),\n    onClick: () => onSelect(node)\n  }, node.constructor.name), /* @__PURE__ */ React.createElement(\"div\", {\n    className: styles.children\n  }, children));\n}\nfunction getStyles(theme) {\n  return {\n    container: css({\n      flexGrow: 1,\n      display: \"flex\",\n      gap: theme.spacing(0.5),\n      flexDirection: \"column\"\n    }),\n    name: css({\n      flexGrow: 1,\n      display: \"flex\",\n      gap: theme.spacing(1),\n      fontSize: theme.typography.bodySmall.fontSize,\n      cursor: \"pointer\",\n      padding: theme.spacing(0, 1),\n      borderRadius: theme.shape.borderRadius(2),\n      position: \"relative\",\n      \"&:hover\": {\n        background: theme.colors.background.secondary\n      }\n    }),\n    selected: css({\n      \"&::before\": {\n        display: \"block\",\n        content: \"' '\",\n        position: \"absolute\",\n        left: 0,\n        width: 4,\n        bottom: 2,\n        top: 2,\n        borderRadius: theme.shape.radius.default,\n        backgroundImage: theme.colors.gradients.brandVertical\n      }\n    }),\n    children: css({\n      flexGrow: 1,\n      display: \"flex\",\n      flexDirection: \"column\",\n      paddingLeft: theme.spacing(1)\n    })\n  };\n}\n\nexport { DebugTreeNode };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n"],"names":[],"mappings":";;;;AAYO,SAAS,aAAc,CAAA,EAAE,IAAM,EAAA,cAAA,EAAgB,UAAmB,EAAA;AACjE,EAAA,MAAA,MAAA,GAAS,WAAW,SAAS,CAAA,CAAA;AACnC,EAAA,MAAM,WAAwB,EAAA,CAAA;AAC9B,EAAA,MAAM,aAAa,IAAS,KAAA,cAAA,CAAA;AAEvB,EAAA,IAAA,CAAA,YAAA,CAAa,CAAC,KAAU,KAAA;AAClB,IAAA,QAAA,CAAA,IAAA;AACN,sBAAA,KAAA,CAAA,cAAA,aAAA,EAAA;QAAc,IAAM,EAAA,KAAA;AAAO,QAAA,GAAA,EAAK,MAAM,KAAM,CAAA,GAAA;AAAK,QAAA,cAAA;AAAgC,QAAA,QAAA;OAAoB,CAAA;AAAA,KAAA,CAAA;GAEzG,CAAA,CAAA;AAED,EACG,uBAAA,KAAA,CAAA,cAAA,KAAA,EAAA;AAAI,IAAA,SAAA,EAAW,MAAO,CAAA,SAAA;GACpB,kBAAA,KAAA,CAAA,cAAA,KAAA,EAAA;AAAI,IAAA,SAAA,EAAW,EAAG,CAAA,MAAA,CAAO,IAAM,EAAA,UAAA,IAAc,OAAO,QAAQ,CAAA;IAAG,OAAS,EAAA,MAAM,SAAS,IAAI,CAAA;AAAA,GAAA,EACzF,KAAK,WAAY,CAAA,IACpB,CACC,kBAAA,KAAA,CAAA,cAAA,KAAA,EAAA;AAAI,IAAA,SAAA,EAAW,MAAO,CAAA,QAAA;AAAA,GAAA,EAAW,QAAS,CAC7C,CAAA,CAAA;AAEJ,CAAA;AAEA,SAAS,UAAU,KAAsB,EAAA;AAChC,EAAA,OAAA;AACL,IAAA,SAAA,EAAW,GAAI,CAAA;MACb,QAAU,EAAA,CAAA;MACV,OAAS,EAAA,MAAA;MACT,GAAK,EAAA,KAAA,CAAM,QAAQ,GAAG,CAAA;MACtB,aAAe,EAAA,QAAA;KAChB,CAAA;AACD,IAAA,IAAA,EAAM,GAAI,CAAA;MACR,QAAU,EAAA,CAAA;MACV,OAAS,EAAA,MAAA;MACT,GAAK,EAAA,KAAA,CAAM,QAAQ,CAAC,CAAA;MACpB,QAAU,EAAA,KAAA,CAAM,WAAW,SAAU,CAAA,QAAA;MACrC,MAAQ,EAAA,SAAA;MACR,OAAS,EAAA,KAAA,CAAM,OAAQ,CAAA,CAAA,EAAG,CAAC,CAAA;MAC3B,YAAc,EAAA,KAAA,CAAM,KAAM,CAAA,YAAA,CAAa,CAAC,CAAA;MACxC,QAAU,EAAA,UAAA;MACV,SAAW,EAAA;QACT,UAAY,EAAA,KAAA,CAAM,OAAO,UAAW,CAAA,SAAA;AAAA,OAAA;KAEvC,CAAA;AACD,IAAA,QAAA,EAAU,GAAI,CAAA;MACZ,WAAa,EAAA;QACX,OAAS,EAAA,OAAA;QACT,OAAS,EAAA,KAAA;QACT,QAAU,EAAA,UAAA;QACV,IAAM,EAAA,CAAA;QACN,KAAO,EAAA,CAAA;QACP,MAAQ,EAAA,CAAA;QACR,GAAK,EAAA,CAAA;QACL,YAAc,EAAA,KAAA,CAAM,MAAM,MAAO,CAAA,OAAA;QACjC,eAAiB,EAAA,KAAA,CAAM,OAAO,SAAU,CAAA,aAAA;AAAA,OAAA;KAE3C,CAAA;AACD,IAAA,QAAA,EAAU,GAAI,CAAA;MACZ,QAAU,EAAA,CAAA;MACV,OAAS,EAAA,MAAA;MACT,aAAe,EAAA,QAAA;MACf,WAAa,EAAA,KAAA,CAAM,QAAQ,CAAC,CAAA;KAC7B,CAAA;AAAA,GAAA,CAAA;AAEL;;;;"}

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

package/dist/esm/dist/esm/components/SceneReactObject.js

@@ -0,0 +1,34 @@
+import React from 'react';
+import { SceneObjectBase } from '../core/SceneObjectBase.js';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+class SceneReactObject extends SceneObjectBase {
+}
+SceneReactObject.Component = ({ model }) => {
+  const { component: Component, props, reactNode } = model.useState();
+  if (Component) {
+    return /* @__PURE__ */ React.createElement(Component, __spreadValues({}, props));
+  }
+  if (reactNode) {
+    return reactNode;
+  }
+  return null;
+};
+
+export { SceneReactObject };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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