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

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

@@ -0,0 +1,286 @@
+import { useState, useEffect } from 'react';
+import { Subscription } from 'rxjs';
+import { v4 } from 'uuid';
+import { EventBusSrv } from '@grafana/data';
+import { SceneComponentWrapper } from './SceneComponentWrapper.js';
+import { SceneObjectStateChangedEvent } from './events.js';
+import { cloneSceneObject } from './sceneGraph/utils.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;
+};
+class SceneObjectBase {
+  constructor(state) {
+    this._isActive = false;
+    this._activationHandlers = [];
+    this._deactivationHandlers = /* @__PURE__ */ new Map();
+    this._subs = new Subscription();
+    this._refCount = 0;
+    this._renderBeforeActivation = false;
+    if (!state.key) {
+      state.key = v4();
+    }
+    this._events = new EventBusSrv();
+    this._state = Object.freeze(state);
+    this._setParent(this._state);
+  }
+  get state() {
+    return this._state;
+  }
+  get isActive() {
+    return this._isActive;
+  }
+  get renderBeforeActivation() {
+    return this._renderBeforeActivation;
+  }
+  get parent() {
+    return this._parent;
+  }
+  get variableDependency() {
+    return this._variableDependency;
+  }
+  get urlSync() {
+    return this._urlSync;
+  }
+  get Component() {
+    return SceneComponentWrapper;
+  }
+  _setParent(state) {
+    forEachChild(state, (child) => {
+      if (child._parent && child._parent !== this) {
+        console.warn(
+          "SceneObject already has a parent set that is different from the new parent. You cannot share the same SceneObject instance in multiple scenes or in multiple different places of the same scene graph. Use SceneObject.clone() to duplicate a SceneObject or store a state key reference and use sceneGraph.findObject to locate it.",
+          child,
+          this
+        );
+      }
+      child._parent = this;
+    });
+  }
+  clearParent() {
+    this._parent = void 0;
+  }
+  subscribeToState(handler) {
+    return this._events.subscribe(SceneObjectStateChangedEvent, (event) => {
+      if (event.payload.changedObject === this) {
+        handler(event.payload.newState, event.payload.prevState);
+      }
+    });
+  }
+  subscribeToEvent(eventType, handler) {
+    return this._events.subscribe(eventType, handler);
+  }
+  setState(update) {
+    const prevState = this._state;
+    const newState = __spreadValues(__spreadValues({}, this._state), update);
+    this._state = Object.freeze(newState);
+    this._setParent(update);
+    this._handleActivationOfChangedStateProps(prevState, newState);
+    this.publishEvent(
+      new SceneObjectStateChangedEvent({
+        prevState,
+        newState,
+        partialUpdate: update,
+        changedObject: this
+      }),
+      true
+    );
+  }
+  _handleActivationOfChangedStateProps(prevState, newState) {
+    if (!this.isActive) {
+      return;
+    }
+    if (prevState.$behaviors !== newState.$behaviors) {
+      this._handleChangedBehaviors(prevState.$behaviors, newState.$behaviors);
+    }
+    if (prevState.$data !== newState.$data) {
+      this._handleChangedStateActivation(prevState.$data, newState.$data);
+    }
+    if (prevState.$variables !== newState.$variables) {
+      this._handleChangedStateActivation(prevState.$variables, newState.$variables);
+    }
+    if (prevState.$timeRange !== newState.$timeRange) {
+      this._handleChangedStateActivation(prevState.$timeRange, newState.$timeRange);
+    }
+  }
+  _handleChangedStateActivation(oldValue, newValue) {
+    if (oldValue) {
+      const deactivationHandler = this._deactivationHandlers.get(oldValue);
+      if (deactivationHandler) {
+        deactivationHandler();
+        this._deactivationHandlers.delete(oldValue);
+      }
+    }
+    if (newValue) {
+      this._deactivationHandlers.set(newValue, newValue.activate());
+    }
+  }
+  _handleChangedBehaviors(oldValue, newValue) {
+    if (oldValue) {
+      for (const oldBehavior of oldValue) {
+        if (!newValue || !newValue.includes(oldBehavior)) {
+          const deactivationHandler = this._deactivationHandlers.get(oldBehavior);
+          if (deactivationHandler) {
+            deactivationHandler();
+            this._deactivationHandlers.delete(oldBehavior);
+          }
+        }
+      }
+    }
+    if (newValue) {
+      for (const newBehavior of newValue) {
+        if (!oldValue || !oldValue.includes(newBehavior)) {
+          this._activateBehavior(newBehavior);
+        }
+      }
+    }
+  }
+  publishEvent(event, bubble) {
+    this._events.publish(event);
+    if (bubble && this.parent) {
+      this.parent.publishEvent(event, bubble);
+    }
+  }
+  getRoot() {
+    return !this._parent ? this : this._parent.getRoot();
+  }
+  _internalActivate() {
+    this._isActive = true;
+    const { $data, $variables, $timeRange, $behaviors } = this.state;
+    this._activationHandlers.forEach((handler) => {
+      const result = handler();
+      if (result) {
+        this._deactivationHandlers.set(result, result);
+      }
+    });
+    if ($timeRange && !$timeRange.isActive) {
+      this._deactivationHandlers.set($timeRange, $timeRange.activate());
+    }
+    if ($variables && !$variables.isActive) {
+      this._deactivationHandlers.set($variables, $variables.activate());
+    }
+    if ($data && !$data.isActive) {
+      this._deactivationHandlers.set($data, $data.activate());
+    }
+    if ($behaviors) {
+      for (const behavior of $behaviors) {
+        this._activateBehavior(behavior);
+      }
+    }
+  }
+  _activateBehavior(behavior) {
+    if (behavior instanceof SceneObjectBase) {
+      this._deactivationHandlers.set(behavior, behavior.activate());
+    } else if (typeof behavior === "function") {
+      const deactivate = behavior(this);
+      if (deactivate) {
+        this._deactivationHandlers.set(behavior, deactivate);
+      }
+    }
+  }
+  activate() {
+    if (!this.isActive) {
+      this._internalActivate();
+    }
+    this._refCount++;
+    let called = false;
+    return () => {
+      this._refCount--;
+      if (called) {
+        const msg = `SceneObject cancelation handler returned by activate() called a second time`;
+        throw new Error(msg);
+      }
+      called = true;
+      if (this._refCount === 0) {
+        this._internalDeactivate();
+      }
+    };
+  }
+  _internalDeactivate() {
+    this._isActive = false;
+    for (let handler of this._deactivationHandlers.values()) {
+      handler();
+    }
+    this._deactivationHandlers.clear();
+    this._events.removeAllListeners();
+    this._subs.unsubscribe();
+    this._subs = new Subscription();
+  }
+  useState() {
+    return useSceneObjectState(this);
+  }
+  forceRender() {
+    this.setState({});
+  }
+  clone(withState) {
+    return cloneSceneObject(this, withState);
+  }
+  addActivationHandler(handler) {
+    this._activationHandlers.push(handler);
+  }
+  forEachChild(callback) {
+    forEachChild(this.state, callback);
+  }
+  getRef() {
+    if (!this._ref) {
+      this._ref = new SceneObjectRef(this);
+    }
+    return this._ref;
+  }
+}
+function useSceneObjectState(model, options) {
+  var _a;
+  const [_, setState] = useState(model.state);
+  const stateAtFirstRender = model.state;
+  const shouldActivateOrKeepAlive = (_a = options == null ? void 0 : options.shouldActivateOrKeepAlive) != null ? _a : false;
+  useEffect(() => {
+    let unactivate;
+    if (shouldActivateOrKeepAlive) {
+      unactivate = model.activate();
+    }
+    const s = model.subscribeToState((state) => {
+      setState(state);
+    });
+    if (model.state !== stateAtFirstRender) {
+      setState(model.state);
+    }
+    return () => {
+      s.unsubscribe();
+      if (unactivate) {
+        unactivate();
+      }
+    };
+  }, [model, shouldActivateOrKeepAlive]);
+  return model.state;
+}
+function forEachChild(state, callback) {
+  for (const propValue of Object.values(state)) {
+    if (propValue instanceof SceneObjectBase) {
+      callback(propValue);
+    }
+    if (Array.isArray(propValue)) {
+      for (const child of propValue) {
+        if (child instanceof SceneObjectBase) {
+          callback(child);
+        }
+      }
+    }
+  }
+}
+
+export { SceneObjectBase, useSceneObjectState };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"SceneObjectBase.js","sources":["../../../../src/core/SceneObjectBase.tsx"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { Subscription, Unsubscribable } from 'rxjs';\nimport { v4 as uuidv4 } from 'uuid';\n\nimport { BusEvent, BusEventHandler, BusEventType, EventBus, EventBusSrv } from '@grafana/data';\nimport {\n  SceneObject,\n  SceneComponent,\n  SceneObjectUrlSyncHandler,\n  SceneStateChangedHandler,\n  SceneActivationHandler,\n  SceneDeactivationHandler,\n  CancelActivationHandler,\n  SceneObjectState,\n  UseStateHookOptions,\n  SceneStatelessBehavior,\n} from './types';\n\nimport { SceneComponentWrapper } from './SceneComponentWrapper';\nimport { SceneObjectStateChangedEvent } from './events';\nimport { cloneSceneObject } from './sceneGraph/utils';\nimport { SceneVariableDependencyConfigLike } from '../variables/types';\nimport { SceneObjectRef } from './SceneObjectRef';\n\nexport abstract class SceneObjectBase<TState extends SceneObjectState = SceneObjectState>\n  implements SceneObject<TState>\n{\n  private _isActive = false;\n  private _state: TState;\n  private _activationHandlers: SceneActivationHandler[] = [];\n  private _deactivationHandlers = new Map<object, SceneDeactivationHandler>();\n  private _ref?: SceneObjectRef<this>;\n\n  protected _events?: EventBus;\n  protected _parent?: SceneObject;\n  protected _subs = new Subscription();\n  protected _refCount = 0;\n  protected _renderBeforeActivation = false;\n\n  protected _variableDependency: SceneVariableDependencyConfigLike | undefined;\n  protected _urlSync: SceneObjectUrlSyncHandler | undefined;\n\n  public constructor(state: TState) {\n    if (!state.key) {\n      state.key = uuidv4();\n    }\n\n    this._events = new EventBusSrv();\n\n    this._state = Object.freeze(state);\n    this._setParent(this._state);\n  }\n\n  /** Current state */\n  public get state(): TState {\n    return this._state;\n  }\n\n  /** True if currently being active (ie displayed for visual objects) */\n  public get isActive(): boolean {\n    return this._isActive;\n  }\n\n  public get renderBeforeActivation(): boolean {\n    return this._renderBeforeActivation;\n  }\n\n  /** Returns the parent, undefined for root object */\n  public get parent(): SceneObject | undefined {\n    return this._parent;\n  }\n\n  /** Returns variable dependency config */\n  public get variableDependency(): SceneVariableDependencyConfigLike | undefined {\n    return this._variableDependency;\n  }\n\n  /** Returns url sync config */\n  public get urlSync(): SceneObjectUrlSyncHandler | undefined {\n    return this._urlSync;\n  }\n\n  /**\n   * Used in render functions when rendering a SceneObject.\n   * Wraps the component in an EditWrapper that handles edit mode\n   */\n  public get Component(): SceneComponent<this> {\n    return SceneComponentWrapper as SceneComponent<this>;\n  }\n\n  private _setParent(state: Partial<TState>) {\n    forEachChild(state, (child) => {\n      // If we already have a parent and it's not this, then we likely have a bug\n      if (child._parent && child._parent !== this) {\n        console.warn(\n          'SceneObject already has a parent set that is different from the new parent. You cannot share the same SceneObject instance in multiple scenes or in multiple different places of the same scene graph. Use SceneObject.clone() to duplicate a SceneObject or store a state key reference and use sceneGraph.findObject to locate it.',\n          child,\n          this\n        );\n      }\n      child._parent = this;\n    });\n  }\n\n  /**\n   * Sometimes you want to move one instance to another parent.\n   * This is a way to do that without getting the console warning.\n   */\n  public clearParent() {\n    this._parent = undefined;\n  }\n\n  /**\n   * Subscribe to the scene state subject\n   **/\n  public subscribeToState(handler: SceneStateChangedHandler<TState>): Unsubscribable {\n    return this._events!.subscribe(SceneObjectStateChangedEvent, (event) => {\n      if (event.payload.changedObject === this) {\n        handler(event.payload.newState as TState, event.payload.prevState as TState);\n      }\n    });\n  }\n\n  /**\n   * Subscribe to the scene event\n   **/\n  public subscribeToEvent<T extends BusEvent>(eventType: BusEventType<T>, handler: BusEventHandler<T>): Unsubscribable {\n    return this._events!.subscribe(eventType, handler);\n  }\n\n  public setState(update: Partial<TState>) {\n    const prevState = this._state;\n    const newState: TState = {\n      ...this._state,\n      ...update,\n    };\n\n    this._state = Object.freeze(newState);\n    this._setParent(update);\n\n    // Handles cases when $data, $timeRange, or $variables are changed\n    this._handleActivationOfChangedStateProps(prevState, newState);\n\n    // Bubble state change event. This is event is subscribed to by UrlSyncManager and UndoManager\n    this.publishEvent(\n      new SceneObjectStateChangedEvent({\n        prevState,\n        newState,\n        partialUpdate: update,\n        changedObject: this,\n      }),\n      true\n    );\n  }\n\n  /**\n   * This handles activation and deactivation of $data, $timeRange and $variables when they change\n   * during the active phase of the scene object.\n   */\n  private _handleActivationOfChangedStateProps(prevState: TState, newState: TState) {\n    if (!this.isActive) {\n      return;\n    }\n\n    if (prevState.$behaviors !== newState.$behaviors) {\n      this._handleChangedBehaviors(prevState.$behaviors, newState.$behaviors);\n    }\n\n    if (prevState.$data !== newState.$data) {\n      this._handleChangedStateActivation(prevState.$data, newState.$data);\n    }\n\n    if (prevState.$variables !== newState.$variables) {\n      this._handleChangedStateActivation(prevState.$variables, newState.$variables);\n    }\n\n    if (prevState.$timeRange !== newState.$timeRange) {\n      this._handleChangedStateActivation(prevState.$timeRange, newState.$timeRange);\n    }\n  }\n\n  private _handleChangedStateActivation(oldValue: SceneObject | undefined, newValue: SceneObject | undefined) {\n    if (oldValue) {\n      const deactivationHandler = this._deactivationHandlers.get(oldValue);\n      if (deactivationHandler) {\n        deactivationHandler();\n        this._deactivationHandlers.delete(oldValue);\n      }\n    }\n\n    if (newValue) {\n      this._deactivationHandlers.set(newValue, newValue.activate());\n    }\n  }\n\n  private _handleChangedBehaviors(\n    oldValue: Array<SceneObject | SceneStatelessBehavior> | undefined,\n    newValue: Array<SceneObject | SceneStatelessBehavior> | undefined\n  ) {\n    // Handle removed behaviors\n    if (oldValue) {\n      for (const oldBehavior of oldValue) {\n        if (!newValue || !newValue.includes(oldBehavior)) {\n          const deactivationHandler = this._deactivationHandlers.get(oldBehavior);\n          if (deactivationHandler) {\n            deactivationHandler();\n            this._deactivationHandlers.delete(oldBehavior);\n          }\n        }\n      }\n    }\n\n    // Handle new behaviors\n    if (newValue) {\n      for (const newBehavior of newValue) {\n        if (!oldValue || !oldValue.includes(newBehavior)) {\n          this._activateBehavior(newBehavior);\n        }\n      }\n    }\n  }\n\n  /*\n   * Publish an event and optionally bubble it up the scene\n   **/\n  public publishEvent(event: BusEvent, bubble?: boolean) {\n    this._events!.publish(event);\n\n    if (bubble && this.parent) {\n      this.parent.publishEvent(event, bubble);\n    }\n  }\n\n  public getRoot(): SceneObject {\n    return !this._parent ? this : this._parent.getRoot();\n  }\n\n  private _internalActivate() {\n    this._isActive = true;\n\n    const { $data, $variables, $timeRange, $behaviors } = this.state;\n\n    this._activationHandlers.forEach((handler) => {\n      const result = handler();\n      if (result) {\n        this._deactivationHandlers.set(result, result);\n      }\n    });\n\n    if ($timeRange && !$timeRange.isActive) {\n      this._deactivationHandlers.set($timeRange, $timeRange.activate());\n    }\n\n    if ($variables && !$variables.isActive) {\n      this._deactivationHandlers.set($variables, $variables.activate());\n    }\n\n    if ($data && !$data.isActive) {\n      this._deactivationHandlers.set($data, $data.activate());\n    }\n\n    if ($behaviors) {\n      for (const behavior of $behaviors) {\n        this._activateBehavior(behavior);\n      }\n    }\n  }\n\n  private _activateBehavior(behavior: SceneObject | SceneStatelessBehavior): SceneDeactivationHandler | void {\n    if (behavior instanceof SceneObjectBase) {\n      this._deactivationHandlers.set(behavior, behavior.activate());\n    } else if (typeof behavior === 'function') {\n      const deactivate = behavior(this);\n      if (deactivate) {\n        this._deactivationHandlers.set(behavior, deactivate);\n      }\n    }\n  }\n\n  /**\n   * This is primarily called from SceneComponentWrapper when the SceneObject's Component is mounted.\n   * But in some scenarios this can also be called directly from another scene object. When called manually from another scene object\n   * make sure to call the returned function when the source scene object is deactivated.\n   */\n  public activate(): CancelActivationHandler {\n    if (!this.isActive) {\n      this._internalActivate();\n    }\n\n    this._refCount++;\n\n    let called = false;\n\n    return () => {\n      this._refCount--;\n\n      if (called) {\n        const msg = `SceneObject cancelation handler returned by activate() called a second time`;\n        throw new Error(msg);\n      }\n\n      called = true;\n\n      if (this._refCount === 0) {\n        this._internalDeactivate();\n      }\n    };\n  }\n\n  /**\n   * Called by the SceneComponentWrapper when the react component is unmounted.\n   * Don't override this, instead use addActivationHandler. The activation handler can return a deactivation handler.\n   */\n  private _internalDeactivate(): void {\n    this._isActive = false;\n\n    for (let handler of this._deactivationHandlers.values()) {\n      handler();\n    }\n\n    this._deactivationHandlers.clear();\n\n    // Clear subscriptions and listeners\n    this._events!.removeAllListeners();\n    this._subs.unsubscribe();\n    this._subs = new Subscription();\n  }\n\n  /**\n   * Utility hook to get and subscribe to state\n   */\n  public useState(): TState {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return useSceneObjectState(this);\n  }\n\n  /** Force a re-render, should only be needed when variable values change */\n  public forceRender(): void {\n    this.setState({});\n  }\n\n  /**\n   * Will create new SceneObject with shallow-cloned state, but all state items of type SceneObject are deep cloned\n   */\n  public clone(withState?: Partial<TState>): this {\n    return cloneSceneObject(this, withState);\n  }\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  public addActivationHandler(handler: SceneActivationHandler) {\n    this._activationHandlers.push(handler);\n  }\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  public forEachChild(callback: (child: SceneObjectBase) => void) {\n    forEachChild(this.state, callback);\n  }\n\n  /** Returns a SceneObjectRef that will resolve to this object */\n  public getRef(): SceneObjectRef<this> {\n    if (!this._ref) {\n      this._ref = new SceneObjectRef(this);\n    }\n\n    return this._ref;\n  }\n}\n\n/**\n * This hook is always returning model.state instead of a useState that remembers the last state emitted on the subject\n * The reason for this is so that if the model instance change this function will always return the latest state.\n */\nexport function useSceneObjectState<TState extends SceneObjectState>(\n  model: SceneObject<TState>,\n  options?: UseStateHookOptions\n): TState {\n  const [_, setState] = useState<TState>(model.state);\n  const stateAtFirstRender = model.state;\n  const shouldActivateOrKeepAlive = options?.shouldActivateOrKeepAlive ?? false;\n\n  useEffect(() => {\n    let unactivate: CancelActivationHandler | undefined;\n\n    if (shouldActivateOrKeepAlive) {\n      unactivate = model.activate();\n    }\n\n    const s = model.subscribeToState((state) => {\n      setState(state);\n    });\n\n    // Re-render component if the state changed between first render and useEffect (mount)\n    if (model.state !== stateAtFirstRender) {\n      setState(model.state);\n    }\n\n    return () => {\n      s.unsubscribe();\n\n      if (unactivate) {\n        unactivate();\n      }\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [model, shouldActivateOrKeepAlive]);\n\n  return model.state;\n}\n\nfunction forEachChild<T extends object>(state: T, callback: (child: SceneObjectBase) => void) {\n  for (const propValue of Object.values(state)) {\n    if (propValue instanceof SceneObjectBase) {\n      callback(propValue);\n    }\n\n    if (Array.isArray(propValue)) {\n      for (const child of propValue) {\n        if (child instanceof SceneObjectBase) {\n          callback(child);\n        }\n      }\n    }\n  }\n}\n"],"names":["uuidv4"],"mappings":"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"}

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

@@ -0,0 +1,32 @@
+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 __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _ref;
+class SceneObjectRef {
+  constructor(ref) {
+    __privateAdd(this, _ref, void 0);
+    __privateSet(this, _ref, ref);
+  }
+  resolve() {
+    return __privateGet(this, _ref);
+  }
+}
+_ref = new WeakMap();
+
+export { SceneObjectRef };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2NlbmVPYmplY3RSZWYuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb3JlL1NjZW5lT2JqZWN0UmVmLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBTY2VuZU9iamVjdFJlZjxUPiB7XG4gICNyZWY6IFQ7XG5cbiAgcHVibGljIGNvbnN0cnVjdG9yKHJlZjogVCkge1xuICAgIHRoaXMuI3JlZiA9IHJlZjtcbiAgfVxuXG4gIHB1YmxpYyByZXNvbHZlKCk6IFQge1xuICAgIHJldHVybiB0aGlzLiNyZWY7XG4gIH1cbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxJQUFBLElBQUEsQ0FBQTtBQUFPLE1BQU0sY0FBa0IsQ0FBQTtBQUFBLEVBR3RCLFlBQVksR0FBUSxFQUFBO0FBRjNCLElBQUEsWUFBQSxDQUFBLElBQUEsRUFBQSxJQUFBLEVBQUEsS0FBQSxDQUFBLENBQUEsQ0FBQTtBQUdFLElBQUEsWUFBQSxDQUFBLElBQUEsRUFBSyxJQUFPLEVBQUEsR0FBQSxDQUFBLENBQUE7QUFBQSxHQUNkO0FBQUEsRUFFTyxPQUFhLEdBQUE7QUFDbEIsSUFBQSxPQUFPLFlBQUssQ0FBQSxJQUFBLEVBQUEsSUFBQSxDQUFBLENBQUE7QUFBQSxHQUNkO0FBQ0YsQ0FBQTtBQVRFLElBQUEsR0FBQSxJQUFBLE9BQUEsRUFBQTs7OzsifQ==

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

@@ -0,0 +1,231 @@
+import { getTimeZone, rangeUtil, toUtc } from '@grafana/data';
+import { SceneObjectUrlSyncConfig } from '../services/SceneObjectUrlSyncConfig.js';
+import { SceneObjectBase } from './SceneObjectBase.js';
+import { getClosest } from './sceneGraph/utils.js';
+import { parseUrlParam } from '../utils/parseUrlParam.js';
+import { evaluateTimeRange } from '../utils/evaluateTimeRange.js';
+import { RefreshEvent, locationService } from '@grafana/runtime';
+import { isValid } from '../utils/date.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 SceneTimeRange extends SceneObjectBase {
+  constructor(state = {}) {
+    var _a;
+    const from = state.from && isValid(state.from) ? state.from : "now-6h";
+    const to = state.to && isValid(state.to) ? state.to : "now";
+    const timeZone = state.timeZone;
+    const value = evaluateTimeRange(
+      from,
+      to,
+      timeZone || getTimeZone(),
+      state.fiscalYearStartMonth,
+      state.UNSAFE_nowDelay
+    );
+    const refreshOnActivate = (_a = state.refreshOnActivate) != null ? _a : { percent: 10 };
+    super(__spreadValues({ from, to, timeZone, value, refreshOnActivate }, state));
+    this._urlSync = new SceneObjectUrlSyncConfig(this, { keys: ["from", "to", "timezone", "time", "time.window"] });
+    this.onTimeRangeChange = (timeRange) => {
+      const update = {};
+      if (typeof timeRange.raw.from === "string") {
+        update.from = timeRange.raw.from;
+      } else {
+        update.from = timeRange.raw.from.toISOString();
+      }
+      if (typeof timeRange.raw.to === "string") {
+        update.to = timeRange.raw.to;
+      } else {
+        update.to = timeRange.raw.to.toISOString();
+      }
+      update.value = evaluateTimeRange(
+        update.from,
+        update.to,
+        this.getTimeZone(),
+        this.state.fiscalYearStartMonth,
+        this.state.UNSAFE_nowDelay
+      );
+      if (update.from !== this.state.from || update.to !== this.state.to) {
+        this._urlSync.performBrowserHistoryAction(() => {
+          this.setState(update);
+        });
+      }
+    };
+    this.onTimeZoneChange = (timeZone) => {
+      this._urlSync.performBrowserHistoryAction(() => {
+        this.setState({ timeZone });
+      });
+    };
+    this.onRefresh = () => {
+      this.setState({
+        value: evaluateTimeRange(
+          this.state.from,
+          this.state.to,
+          this.getTimeZone(),
+          this.state.fiscalYearStartMonth,
+          this.state.UNSAFE_nowDelay
+        )
+      });
+      this.publishEvent(new RefreshEvent(), true);
+    };
+    this.addActivationHandler(this._onActivate.bind(this));
+  }
+  _onActivate() {
+    if (!this.state.timeZone) {
+      const timeZoneSource = this.getTimeZoneSource();
+      if (timeZoneSource !== this) {
+        this._subs.add(
+          timeZoneSource.subscribeToState((n, p) => {
+            if (n.timeZone !== void 0 && n.timeZone !== p.timeZone) {
+              this.setState({
+                value: evaluateTimeRange(
+                  this.state.from,
+                  this.state.to,
+                  timeZoneSource.getTimeZone(),
+                  this.state.fiscalYearStartMonth,
+                  this.state.UNSAFE_nowDelay
+                )
+              });
+            }
+          })
+        );
+      }
+    }
+    if (rangeUtil.isRelativeTimeRange(this.state.value.raw)) {
+      this.refreshIfStale();
+    }
+  }
+  refreshIfStale() {
+    var _a, _b, _c, _d;
+    let ms;
+    if (((_b = (_a = this.state) == null ? void 0 : _a.refreshOnActivate) == null ? void 0 : _b.percent) !== void 0) {
+      ms = this.calculatePercentOfInterval(this.state.refreshOnActivate.percent);
+    }
+    if (((_d = (_c = this.state) == null ? void 0 : _c.refreshOnActivate) == null ? void 0 : _d.afterMs) !== void 0) {
+      ms = Math.min(this.state.refreshOnActivate.afterMs, ms != null ? ms : Infinity);
+    }
+    if (ms !== void 0) {
+      this.refreshRange(ms);
+    }
+  }
+  getTimeZoneSource() {
+    if (!this.parent || !this.parent.parent) {
+      return this;
+    }
+    const source = getClosest(this.parent.parent, (o) => {
+      if (o.state.$timeRange && o.state.$timeRange.state.timeZone) {
+        return o.state.$timeRange;
+      }
+      return void 0;
+    });
+    if (!source) {
+      return this;
+    }
+    return source;
+  }
+  refreshRange(refreshAfterMs) {
+    var _a;
+    const value = evaluateTimeRange(
+      this.state.from,
+      this.state.to,
+      (_a = this.state.timeZone) != null ? _a : getTimeZone(),
+      this.state.fiscalYearStartMonth,
+      this.state.UNSAFE_nowDelay
+    );
+    const diff = value.to.diff(this.state.value.to, "milliseconds");
+    if (diff >= refreshAfterMs) {
+      this.setState({
+        value
+      });
+    }
+  }
+  calculatePercentOfInterval(percent) {
+    const intervalMs = this.state.value.to.diff(this.state.value.from, "milliseconds");
+    return Math.ceil(intervalMs / percent);
+  }
+  getTimeZone() {
+    if (this.state.timeZone) {
+      return this.state.timeZone;
+    }
+    const timeZoneSource = this.getTimeZoneSource();
+    if (timeZoneSource !== this) {
+      return timeZoneSource.state.timeZone;
+    }
+    return getTimeZone();
+  }
+  getUrlState() {
+    const params = locationService.getSearchObject();
+    const urlValues = { from: this.state.from, to: this.state.to, timezone: this.getTimeZone() };
+    if (params.time && params["time.window"]) {
+      urlValues.time = null;
+      urlValues["time.window"] = null;
+    }
+    return urlValues;
+  }
+  updateFromUrl(values) {
+    var _a, _b, _c;
+    const update = {};
+    let from = parseUrlParam(values.from);
+    let to = parseUrlParam(values.to);
+    if (values.time && values["time.window"]) {
+      const time = Array.isArray(values.time) ? values.time[0] : values.time;
+      const timeWindow = Array.isArray(values["time.window"]) ? values["time.window"][0] : values["time.window"];
+      const timeRange = getTimeWindow(time, timeWindow);
+      if (timeRange.from && isValid(timeRange.from)) {
+        from = timeRange.from;
+      }
+      if (timeRange.to && isValid(timeRange.to)) {
+        to = timeRange.to;
+      }
+    }
+    if (from && isValid(from)) {
+      update.from = from;
+    }
+    if (to && isValid(to)) {
+      update.to = to;
+    }
+    if (typeof values.timezone === "string") {
+      update.timeZone = values.timezone !== "" ? values.timezone : void 0;
+    }
+    if (Object.keys(update).length === 0) {
+      return;
+    }
+    update.value = evaluateTimeRange(
+      (_a = update.from) != null ? _a : this.state.from,
+      (_b = update.to) != null ? _b : this.state.to,
+      (_c = update.timeZone) != null ? _c : this.getTimeZone(),
+      this.state.fiscalYearStartMonth,
+      this.state.UNSAFE_nowDelay
+    );
+    return this.setState(update);
+  }
+}
+function getTimeWindow(time, timeWindow) {
+  const valueTime = isNaN(Date.parse(time)) ? parseInt(time, 10) : Date.parse(time);
+  let timeWindowMs;
+  if (timeWindow.match(/^\d+$/) && parseInt(timeWindow, 10)) {
+    timeWindowMs = parseInt(timeWindow, 10);
+  } else {
+    timeWindowMs = rangeUtil.intervalToMs(timeWindow);
+  }
+  return {
+    from: toUtc(valueTime - timeWindowMs / 2).toISOString(),
+    to: toUtc(valueTime + timeWindowMs / 2).toISOString()
+  };
+}
+
+export { SceneTimeRange };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"SceneTimeRange.js","sources":["../../../../src/core/SceneTimeRange.tsx"],"sourcesContent":["import { getTimeZone, rangeUtil, TimeRange, toUtc } from '@grafana/data';\nimport { TimeZone } from '@grafana/schema';\n\nimport { SceneObjectUrlSyncConfig } from '../services/SceneObjectUrlSyncConfig';\n\nimport { SceneObjectBase } from './SceneObjectBase';\nimport { SceneTimeRangeLike, SceneTimeRangeState, SceneObjectUrlValues } from './types';\nimport { getClosest } from './sceneGraph/utils';\nimport { parseUrlParam } from '../utils/parseUrlParam';\nimport { evaluateTimeRange } from '../utils/evaluateTimeRange';\nimport { locationService, RefreshEvent } from '@grafana/runtime';\nimport { isValid } from '../utils/date';\n\nexport class SceneTimeRange extends SceneObjectBase<SceneTimeRangeState> implements SceneTimeRangeLike {\n  protected _urlSync = new SceneObjectUrlSyncConfig(this, { keys: ['from', 'to', 'timezone', 'time', 'time.window'] });\n\n  public constructor(state: Partial<SceneTimeRangeState> = {}) {\n    const from = state.from && isValid(state.from) ? state.from : 'now-6h';\n    const to = state.to && isValid(state.to) ? state.to : 'now';\n\n    const timeZone = state.timeZone;\n    const value = evaluateTimeRange(\n      from,\n      to,\n      timeZone || getTimeZone(),\n      state.fiscalYearStartMonth,\n      state.UNSAFE_nowDelay\n    );\n    const refreshOnActivate = state.refreshOnActivate ?? { percent: 10 };\n    super({ from, to, timeZone, value, refreshOnActivate, ...state });\n\n    this.addActivationHandler(this._onActivate.bind(this));\n  }\n\n  private _onActivate() {\n    // When SceneTimeRange has no time zone provided, find closest source of time zone and subscribe to it\n    if (!this.state.timeZone) {\n      const timeZoneSource = this.getTimeZoneSource();\n      if (timeZoneSource !== this) {\n        this._subs.add(\n          timeZoneSource.subscribeToState((n, p) => {\n            if (n.timeZone !== undefined && n.timeZone !== p.timeZone) {\n              this.setState({\n                value: evaluateTimeRange(\n                  this.state.from,\n                  this.state.to,\n                  timeZoneSource.getTimeZone(),\n                  this.state.fiscalYearStartMonth,\n                  this.state.UNSAFE_nowDelay\n                ),\n              });\n            }\n          })\n        );\n      }\n    }\n\n    if (rangeUtil.isRelativeTimeRange(this.state.value.raw)) {\n      this.refreshIfStale();\n    }\n  }\n\n  private refreshIfStale() {\n    let ms;\n    if (this.state?.refreshOnActivate?.percent !== undefined) {\n      ms = this.calculatePercentOfInterval(this.state.refreshOnActivate.percent);\n    }\n    if (this.state?.refreshOnActivate?.afterMs !== undefined) {\n      ms = Math.min(this.state.refreshOnActivate.afterMs, ms ?? Infinity);\n    }\n    if (ms !== undefined) {\n      this.refreshRange(ms);\n    }\n  }\n\n  /**\n   * Will traverse up the scene graph to find the closest SceneTimeRangeLike with time zone set\n   */\n  private getTimeZoneSource() {\n    if (!this.parent || !this.parent.parent) {\n      return this;\n    }\n    // Find the closest source of time zone\n    const source = getClosest<SceneTimeRangeLike>(this.parent.parent, (o) => {\n      if (o.state.$timeRange && o.state.$timeRange.state.timeZone) {\n        return o.state.$timeRange;\n      }\n      return undefined;\n    });\n\n    if (!source) {\n      return this;\n    }\n\n    return source;\n  }\n\n  /**\n   * Refreshes time range if it is older than the invalidation interval\n   * @param refreshAfterMs invalidation interval (milliseconds)\n   * @private\n   */\n  private refreshRange(refreshAfterMs: number) {\n    const value = evaluateTimeRange(\n      this.state.from,\n      this.state.to,\n      this.state.timeZone ?? getTimeZone(),\n      this.state.fiscalYearStartMonth,\n      this.state.UNSAFE_nowDelay\n    );\n\n    const diff = value.to.diff(this.state.value.to, 'milliseconds');\n    if (diff >= refreshAfterMs) {\n      this.setState({\n        value,\n      });\n    }\n  }\n\n  private calculatePercentOfInterval(percent: number): number {\n    const intervalMs = this.state.value.to.diff(this.state.value.from, 'milliseconds');\n    return Math.ceil(intervalMs / percent);\n  }\n\n  public getTimeZone(): TimeZone {\n    // Return local time zone if provided\n    if (this.state.timeZone) {\n      return this.state.timeZone;\n    }\n\n    // Resolve higher level time zone source\n    const timeZoneSource = this.getTimeZoneSource();\n    if (timeZoneSource !== this) {\n      return timeZoneSource.state.timeZone!;\n    }\n\n    // Return default time zone\n    return getTimeZone();\n  }\n\n  public onTimeRangeChange = (timeRange: TimeRange) => {\n    const update: Partial<SceneTimeRangeState> = {};\n\n    if (typeof timeRange.raw.from === 'string') {\n      update.from = timeRange.raw.from;\n    } else {\n      update.from = timeRange.raw.from.toISOString();\n    }\n\n    if (typeof timeRange.raw.to === 'string') {\n      update.to = timeRange.raw.to;\n    } else {\n      update.to = timeRange.raw.to.toISOString();\n    }\n\n    update.value = evaluateTimeRange(\n      update.from,\n      update.to,\n      this.getTimeZone(),\n      this.state.fiscalYearStartMonth,\n      this.state.UNSAFE_nowDelay\n    );\n\n    // Only update if time range actually changed\n    if (update.from !== this.state.from || update.to !== this.state.to) {\n      this._urlSync.performBrowserHistoryAction(() => {\n        this.setState(update);\n      });\n    }\n  };\n\n  public onTimeZoneChange = (timeZone: TimeZone) => {\n    this._urlSync.performBrowserHistoryAction(() => {\n      this.setState({ timeZone });\n    });\n  };\n\n  public onRefresh = () => {\n    this.setState({\n      value: evaluateTimeRange(\n        this.state.from,\n        this.state.to,\n        this.getTimeZone(),\n        this.state.fiscalYearStartMonth,\n        this.state.UNSAFE_nowDelay\n      ),\n    });\n\n    this.publishEvent(new RefreshEvent(), true);\n  };\n\n  public getUrlState() {\n    const params = locationService.getSearchObject();\n    const urlValues: SceneObjectUrlValues = { from: this.state.from, to: this.state.to, timezone: this.getTimeZone() };\n\n    // Clear time and time.window once they are converted to from and to\n    if (params.time && params['time.window']) {\n      urlValues.time = null;\n      urlValues['time.window'] = null;\n    }\n\n    return urlValues;\n  }\n\n  public updateFromUrl(values: SceneObjectUrlValues) {\n    const update: Partial<SceneTimeRangeState> = {};\n\n    let from = parseUrlParam(values.from);\n    let to = parseUrlParam(values.to);\n\n    if (values.time && values['time.window']) {\n      const time = Array.isArray(values.time) ? values.time[0] : values.time;\n      const timeWindow = Array.isArray(values['time.window']) ? values['time.window'][0] : values['time.window'];\n      const timeRange = getTimeWindow(time, timeWindow);\n      if (timeRange.from && isValid(timeRange.from)) {\n        from = timeRange.from;\n      }\n\n      if (timeRange.to && isValid(timeRange.to)) {\n        to = timeRange.to;\n      }\n    }\n\n    if (from && isValid(from)) {\n      update.from = from;\n    }\n\n    if (to && isValid(to)) {\n      update.to = to;\n    }\n\n    if (typeof values.timezone === 'string') {\n      update.timeZone = values.timezone !== '' ? values.timezone : undefined;\n    }\n\n    if (Object.keys(update).length === 0) {\n      return;\n    }\n\n    update.value = evaluateTimeRange(\n      update.from ?? this.state.from,\n      update.to ?? this.state.to,\n      update.timeZone ?? this.getTimeZone(),\n      this.state.fiscalYearStartMonth,\n      this.state.UNSAFE_nowDelay\n    );\n\n    return this.setState(update);\n  }\n}\n\n/**\n * Calculates the duration of the time range from time-time.window/2 to time+time.window/2. Both be specified in ms. For example ?time=1500000000000&time.window=10000 results in a 10-second time range from 1499999995000 to 1500000005000`.\n * @param time - time in ms\n * @param timeWindow - time window in ms or interval string\n */\nfunction getTimeWindow(time: string, timeWindow: string) {\n  // Parse the time, assuming it could be an ISO string or a number in milliseconds\n  const valueTime = isNaN(Date.parse(time)) ? parseInt(time, 10) : Date.parse(time);\n\n  let timeWindowMs;\n\n  if (timeWindow.match(/^\\d+$/) && parseInt(timeWindow, 10)) {\n    // when time window is specified in ms\n    timeWindowMs = parseInt(timeWindow, 10);\n  } else {\n    timeWindowMs = rangeUtil.intervalToMs(timeWindow);\n  }\n\n  return {\n    from: toUtc(valueTime - timeWindowMs / 2).toISOString(),\n    to: toUtc(valueTime + timeWindowMs / 2).toISOString(),\n  };\n}\n"],"names":[],"mappings":"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"}