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

package/dist/esm/src/services/UrlSyncManager.js

@@ -0,0 +1,167 @@
+import { locationService } from '@grafana/runtime';
+import { SceneObjectStateChangedEvent } from '../core/events.js';
+import { writeSceneLog } from '../utils/writeSceneLog.js';
+import { Subscription } from 'rxjs';
+import { UniqueUrlKeyMapper } from './UniqueUrlKeyMapper.js';
+import { getUrlState, syncStateFromUrl, isUrlValueEqual } from './utils.js';
+import { BusEventWithPayload } from '@grafana/data';
+import { useMemo } from 'react';
+
+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 _cache, _location;
+class NewSceneObjectAddedEvent extends BusEventWithPayload {
+}
+NewSceneObjectAddedEvent.type = "new-scene-object-added";
+class UrlSyncManager {
+  constructor(_options = {}, locationService$1 = locationService) {
+    this._urlKeyMapper = new UniqueUrlKeyMapper();
+    this._options = _options;
+    this._locationService = locationService$1;
+    this._paramsCache = new UrlParamsCache(locationService$1);
+  }
+  initSync(root) {
+    var _a;
+    if (this._subs) {
+      writeSceneLog("UrlSyncManager", "Unregister previous scene state subscription", (_a = this._sceneRoot) == null ? void 0 : _a.state.key);
+      this._subs.unsubscribe();
+    }
+    writeSceneLog("UrlSyncManager", "init", root.state.key);
+    this._sceneRoot = root;
+    this._subs = new Subscription();
+    this._subs.add(
+      root.subscribeToEvent(SceneObjectStateChangedEvent, (evt) => {
+        this.handleSceneObjectStateChanged(evt.payload.changedObject);
+      })
+    );
+    this._subs.add(
+      root.subscribeToEvent(NewSceneObjectAddedEvent, (evt) => {
+        this.handleNewObject(evt.payload);
+      })
+    );
+    this._urlKeyMapper.clear();
+    this._lastLocation = this._locationService.getLocation();
+    this.handleNewObject(this._sceneRoot);
+    if (this._options.updateUrlOnInit) {
+      const urlState = getUrlState(root);
+      if (isUrlStateDifferent(urlState, this._paramsCache.getParams())) {
+        this._locationService.partial(urlState, true);
+      }
+    }
+  }
+  cleanUp(root) {
+    if (this._sceneRoot !== root) {
+      return;
+    }
+    writeSceneLog("UrlSyncManager", "Clean up");
+    if (this._subs) {
+      this._subs.unsubscribe();
+      this._subs = void 0;
+      writeSceneLog(
+        "UrlSyncManager",
+        "Root deactived, unsub to state",
+        "same key",
+        this._sceneRoot.state.key === root.state.key
+      );
+    }
+    this._sceneRoot = void 0;
+    this._lastLocation = void 0;
+  }
+  handleNewLocation(location) {
+    if (!this._sceneRoot || this._lastLocation === location) {
+      return;
+    }
+    writeSceneLog("UrlSyncManager", "handleNewLocation");
+    this._lastLocation = location;
+    syncStateFromUrl(this._sceneRoot, this._paramsCache.getParams(), this._urlKeyMapper);
+  }
+  handleNewObject(sceneObj) {
+    if (!this._sceneRoot) {
+      return;
+    }
+    syncStateFromUrl(sceneObj, this._paramsCache.getParams(), this._urlKeyMapper);
+  }
+  handleSceneObjectStateChanged(changedObject) {
+    var _a, _b;
+    if (!changedObject.urlSync) {
+      return;
+    }
+    const newUrlState = changedObject.urlSync.getUrlState();
+    const searchParams = this._locationService.getSearch();
+    const mappedUpdated = {};
+    for (const [key, newUrlValue] of Object.entries(newUrlState)) {
+      const uniqueKey = this._urlKeyMapper.getUniqueKey(key, changedObject);
+      const currentUrlValue = searchParams.getAll(uniqueKey);
+      if (!isUrlValueEqual(currentUrlValue, newUrlValue)) {
+        mappedUpdated[uniqueKey] = newUrlValue;
+      }
+    }
+    if (Object.keys(mappedUpdated).length > 0) {
+      const shouldCreateHistoryEntry = (_b = (_a = changedObject.urlSync).shouldCreateHistoryStep) == null ? void 0 : _b.call(_a, newUrlState);
+      const shouldReplace = shouldCreateHistoryEntry !== true;
+      writeSceneLog("UrlSyncManager", "onStateChange updating URL");
+      this._locationService.partial(mappedUpdated, shouldReplace);
+      this._lastLocation = this._locationService.getLocation();
+    }
+  }
+  getUrlState(root) {
+    return getUrlState(root);
+  }
+}
+class UrlParamsCache {
+  constructor(locationService) {
+    this.locationService = locationService;
+    __privateAdd(this, _cache, void 0);
+    __privateAdd(this, _location, void 0);
+  }
+  getParams() {
+    const location = this.locationService.getLocation();
+    if (__privateGet(this, _location) === location) {
+      return __privateGet(this, _cache);
+    }
+    __privateSet(this, _location, location);
+    __privateSet(this, _cache, new URLSearchParams(location.search));
+    return __privateGet(this, _cache);
+  }
+}
+_cache = new WeakMap();
+_location = new WeakMap();
+function isUrlStateDifferent(sceneUrlState, currentParams) {
+  for (let key in sceneUrlState) {
+    if (!isUrlValueEqual(currentParams.getAll(key), sceneUrlState[key])) {
+      return true;
+    }
+  }
+  return false;
+}
+function useUrlSyncManager(options, locationService) {
+  return useMemo(
+    () => new UrlSyncManager(
+      {
+        updateUrlOnInit: options.updateUrlOnInit,
+        createBrowserHistorySteps: options.createBrowserHistorySteps
+      },
+      locationService
+    ),
+    [options.updateUrlOnInit, options.createBrowserHistorySteps, locationService]
+  );
+}
+
+export { NewSceneObjectAddedEvent, UrlSyncManager, useUrlSyncManager };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"UrlSyncManager.js","sources":["../../../../src/services/UrlSyncManager.ts"],"sourcesContent":["import { Location } from 'history';\n\nimport { LocationService, locationService as locationServiceRuntime } from '@grafana/runtime';\n\nimport { SceneObjectStateChangedEvent } from '../core/events';\nimport { SceneObject, SceneObjectUrlValues, SceneUrlSyncOptions } from '../core/types';\nimport { writeSceneLog } from '../utils/writeSceneLog';\nimport { Subscription } from 'rxjs';\nimport { UniqueUrlKeyMapper } from './UniqueUrlKeyMapper';\nimport { getUrlState, isUrlValueEqual, syncStateFromUrl } from './utils';\nimport { BusEventWithPayload } from '@grafana/data';\nimport { useMemo } from 'react';\n\nexport interface UrlSyncManagerLike {\n  initSync(root: SceneObject): void;\n  cleanUp(root: SceneObject): void;\n  handleNewLocation(location: Location): void;\n  handleNewObject(sceneObj: SceneObject): void;\n}\n\n/**\n * Notify the url sync manager of a new object that has been added to the scene\n * that needs to init state from URL.\n */\nexport class NewSceneObjectAddedEvent extends BusEventWithPayload<SceneObject> {\n  public static readonly type = 'new-scene-object-added';\n}\n\nexport class UrlSyncManager implements UrlSyncManagerLike {\n  private _urlKeyMapper = new UniqueUrlKeyMapper();\n  private _sceneRoot?: SceneObject;\n  private _subs: Subscription | undefined;\n  private _lastLocation: Location | undefined;\n  private _locationService: LocationService;\n  private _paramsCache: UrlParamsCache;\n  private _options: SceneUrlSyncOptions;\n\n  public constructor(_options: SceneUrlSyncOptions = {}, locationService: LocationService = locationServiceRuntime) {\n    this._options = _options;\n    this._locationService = locationService;\n    this._paramsCache = new UrlParamsCache(locationService);\n  }\n\n  /**\n   * Updates the current scene state to match URL state.\n   */\n  public initSync(root: SceneObject) {\n    if (this._subs) {\n      writeSceneLog('UrlSyncManager', 'Unregister previous scene state subscription', this._sceneRoot?.state.key);\n      this._subs.unsubscribe();\n    }\n\n    writeSceneLog('UrlSyncManager', 'init', root.state.key);\n\n    this._sceneRoot = root;\n    this._subs = new Subscription();\n\n    this._subs.add(\n      root.subscribeToEvent(SceneObjectStateChangedEvent, (evt) => {\n        this.handleSceneObjectStateChanged(evt.payload.changedObject);\n      })\n    );\n\n    this._subs.add(\n      root.subscribeToEvent(NewSceneObjectAddedEvent, (evt) => {\n        this.handleNewObject(evt.payload);\n      })\n    );\n\n    this._urlKeyMapper.clear();\n    this._lastLocation = this._locationService.getLocation();\n\n    // Sync current url with state\n    this.handleNewObject(this._sceneRoot);\n\n    if (this._options.updateUrlOnInit) {\n      // Get current url state and update url to match\n      const urlState = getUrlState(root);\n\n      if (isUrlStateDifferent(urlState, this._paramsCache.getParams())) {\n        this._locationService.partial(urlState, true);\n      }\n    }\n  }\n\n  public cleanUp(root: SceneObject) {\n    // Ignore this if we have a new or different root\n    if (this._sceneRoot !== root) {\n      return;\n    }\n\n    writeSceneLog('UrlSyncManager', 'Clean up');\n\n    if (this._subs) {\n      this._subs.unsubscribe();\n      this._subs = undefined;\n\n      writeSceneLog(\n        'UrlSyncManager',\n        'Root deactived, unsub to state',\n        'same key',\n        this._sceneRoot.state.key === root.state.key\n      );\n    }\n\n    this._sceneRoot = undefined;\n    this._lastLocation = undefined;\n  }\n\n  public handleNewLocation(location: Location) {\n    if (!this._sceneRoot || this._lastLocation === location) {\n      return;\n    }\n\n    writeSceneLog('UrlSyncManager', 'handleNewLocation');\n\n    this._lastLocation = location;\n\n    // Sync scene state tree from url\n    syncStateFromUrl(this._sceneRoot!, this._paramsCache.getParams(), this._urlKeyMapper);\n  }\n\n  public handleNewObject(sceneObj: SceneObject) {\n    if (!this._sceneRoot) {\n      return;\n    }\n\n    syncStateFromUrl(sceneObj, this._paramsCache.getParams(), this._urlKeyMapper);\n  }\n\n  private handleSceneObjectStateChanged(changedObject: SceneObject) {\n    if (!changedObject.urlSync) {\n      return;\n    }\n\n    const newUrlState = changedObject.urlSync.getUrlState();\n\n    const searchParams = this._locationService.getSearch();\n    const mappedUpdated: SceneObjectUrlValues = {};\n\n    for (const [key, newUrlValue] of Object.entries(newUrlState)) {\n      const uniqueKey = this._urlKeyMapper.getUniqueKey(key, changedObject);\n      const currentUrlValue = searchParams.getAll(uniqueKey);\n\n      if (!isUrlValueEqual(currentUrlValue, newUrlValue)) {\n        mappedUpdated[uniqueKey] = newUrlValue;\n      }\n    }\n\n    if (Object.keys(mappedUpdated).length > 0) {\n      const shouldCreateHistoryEntry = changedObject.urlSync.shouldCreateHistoryStep?.(newUrlState);\n      const shouldReplace = shouldCreateHistoryEntry !== true;\n\n      writeSceneLog('UrlSyncManager', 'onStateChange updating URL');\n      this._locationService.partial(mappedUpdated, shouldReplace);\n\n      /// Mark the location already handled\n      this._lastLocation = this._locationService.getLocation();\n    }\n  }\n\n  public getUrlState(root: SceneObject): SceneObjectUrlValues {\n    return getUrlState(root);\n  }\n}\n\nclass UrlParamsCache {\n  #cache: URLSearchParams | undefined;\n  #location: Location | undefined;\n\n  public constructor(private locationService: LocationService) {}\n\n  public getParams(): URLSearchParams {\n    const location = this.locationService.getLocation();\n\n    if (this.#location === location) {\n      return this.#cache!;\n    }\n\n    this.#location = location;\n    this.#cache = new URLSearchParams(location.search);\n\n    return this.#cache;\n  }\n}\n\nfunction isUrlStateDifferent(sceneUrlState: SceneObjectUrlValues, currentParams: URLSearchParams) {\n  for (let key in sceneUrlState) {\n    if (!isUrlValueEqual(currentParams.getAll(key), sceneUrlState[key])) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Creates a new memoized instance of the UrlSyncManager based on options\n */\nexport function useUrlSyncManager(options: SceneUrlSyncOptions, locationService: LocationService): UrlSyncManagerLike {\n  return useMemo(\n    () =>\n      new UrlSyncManager(\n        {\n          updateUrlOnInit: options.updateUrlOnInit,\n          createBrowserHistorySteps: options.createBrowserHistorySteps,\n        },\n        locationService\n      ),\n    [options.updateUrlOnInit, options.createBrowserHistorySteps, locationService]\n  );\n}\n"],"names":["locationService","locationServiceRuntime"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAA,MAAA,EAAA,SAAA,CAAA;AAwBO,MAAM,iCAAiC,mBAAiC,CAAA;AAE/E,CAAA;AAFa,wBAAA,CACY,IAAO,GAAA,wBAAA,CAAA;AAGzB,MAAM,cAA6C,CAAA;AAAA,EASjD,WAAY,CAAA,QAAA,GAAgC,EAAC,EAAGA,oBAAmCC,eAAwB,EAAA;AARlH,IAAQ,IAAA,CAAA,aAAA,GAAgB,IAAI,kBAAmB,EAAA,CAAA;AAS7C,IAAA,IAAA,CAAK,QAAW,GAAA,QAAA,CAAA;AAChB,IAAA,IAAA,CAAK,gBAAmB,GAAAD,iBAAA,CAAA;AACxB,IAAK,IAAA,CAAA,YAAA,GAAe,IAAI,cAAA,CAAeA,iBAAe,CAAA,CAAA;AAAA,GACxD;AAAA,EAKO,SAAS,IAAmB,EAAA;AA9CrC,IAAA,IAAA,EAAA,CAAA;AA+CI,IAAA,IAAI,KAAK,KAAO,EAAA;AACd,MAAA,aAAA,CAAc,kBAAkB,8CAAgD,EAAA,CAAA,EAAA,GAAA,IAAA,CAAK,UAAL,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAiB,MAAM,GAAG,CAAA,CAAA;AAC1G,MAAA,IAAA,CAAK,MAAM,WAAY,EAAA,CAAA;AAAA,KACzB;AAEA,IAAA,aAAA,CAAc,gBAAkB,EAAA,MAAA,EAAQ,IAAK,CAAA,KAAA,CAAM,GAAG,CAAA,CAAA;AAEtD,IAAA,IAAA,CAAK,UAAa,GAAA,IAAA,CAAA;AAClB,IAAK,IAAA,CAAA,KAAA,GAAQ,IAAI,YAAa,EAAA,CAAA;AAE9B,IAAA,IAAA,CAAK,KAAM,CAAA,GAAA;AAAA,MACT,IAAK,CAAA,gBAAA,CAAiB,4BAA8B,EAAA,CAAC,GAAQ,KAAA;AAC3D,QAAK,IAAA,CAAA,6BAAA,CAA8B,GAAI,CAAA,OAAA,CAAQ,aAAa,CAAA,CAAA;AAAA,OAC7D,CAAA;AAAA,KACH,CAAA;AAEA,IAAA,IAAA,CAAK,KAAM,CAAA,GAAA;AAAA,MACT,IAAK,CAAA,gBAAA,CAAiB,wBAA0B,EAAA,CAAC,GAAQ,KAAA;AACvD,QAAK,IAAA,CAAA,eAAA,CAAgB,IAAI,OAAO,CAAA,CAAA;AAAA,OACjC,CAAA;AAAA,KACH,CAAA;AAEA,IAAA,IAAA,CAAK,cAAc,KAAM,EAAA,CAAA;AACzB,IAAK,IAAA,CAAA,aAAA,GAAgB,IAAK,CAAA,gBAAA,CAAiB,WAAY,EAAA,CAAA;AAGvD,IAAK,IAAA,CAAA,eAAA,CAAgB,KAAK,UAAU,CAAA,CAAA;AAEpC,IAAI,IAAA,IAAA,CAAK,SAAS,eAAiB,EAAA;AAEjC,MAAM,MAAA,QAAA,GAAW,YAAY,IAAI,CAAA,CAAA;AAEjC,MAAA,IAAI,oBAAoB,QAAU,EAAA,IAAA,CAAK,YAAa,CAAA,SAAA,EAAW,CAAG,EAAA;AAChE,QAAK,IAAA,CAAA,gBAAA,CAAiB,OAAQ,CAAA,QAAA,EAAU,IAAI,CAAA,CAAA;AAAA,OAC9C;AAAA,KACF;AAAA,GACF;AAAA,EAEO,QAAQ,IAAmB,EAAA;AAEhC,IAAI,IAAA,IAAA,CAAK,eAAe,IAAM,EAAA;AAC5B,MAAA,OAAA;AAAA,KACF;AAEA,IAAA,aAAA,CAAc,kBAAkB,UAAU,CAAA,CAAA;AAE1C,IAAA,IAAI,KAAK,KAAO,EAAA;AACd,MAAA,IAAA,CAAK,MAAM,WAAY,EAAA,CAAA;AACvB,MAAA,IAAA,CAAK,KAAQ,GAAA,KAAA,CAAA,CAAA;AAEb,MAAA,aAAA;AAAA,QACE,gBAAA;AAAA,QACA,gCAAA;AAAA,QACA,UAAA;AAAA,QACA,IAAK,CAAA,UAAA,CAAW,KAAM,CAAA,GAAA,KAAQ,KAAK,KAAM,CAAA,GAAA;AAAA,OAC3C,CAAA;AAAA,KACF;AAEA,IAAA,IAAA,CAAK,UAAa,GAAA,KAAA,CAAA,CAAA;AAClB,IAAA,IAAA,CAAK,aAAgB,GAAA,KAAA,CAAA,CAAA;AAAA,GACvB;AAAA,EAEO,kBAAkB,QAAoB,EAAA;AAC3C,IAAA,IAAI,CAAC,IAAA,CAAK,UAAc,IAAA,IAAA,CAAK,kBAAkB,QAAU,EAAA;AACvD,MAAA,OAAA;AAAA,KACF;AAEA,IAAA,aAAA,CAAc,kBAAkB,mBAAmB,CAAA,CAAA;AAEnD,IAAA,IAAA,CAAK,aAAgB,GAAA,QAAA,CAAA;AAGrB,IAAA,gBAAA,CAAiB,KAAK,UAAa,EAAA,IAAA,CAAK,aAAa,SAAU,EAAA,EAAG,KAAK,aAAa,CAAA,CAAA;AAAA,GACtF;AAAA,EAEO,gBAAgB,QAAuB,EAAA;AAC5C,IAAI,IAAA,CAAC,KAAK,UAAY,EAAA;AACpB,MAAA,OAAA;AAAA,KACF;AAEA,IAAA,gBAAA,CAAiB,UAAU,IAAK,CAAA,YAAA,CAAa,SAAU,EAAA,EAAG,KAAK,aAAa,CAAA,CAAA;AAAA,GAC9E;AAAA,EAEQ,8BAA8B,aAA4B,EAAA;AAlIpE,IAAA,IAAA,EAAA,EAAA,EAAA,CAAA;AAmII,IAAI,IAAA,CAAC,cAAc,OAAS,EAAA;AAC1B,MAAA,OAAA;AAAA,KACF;AAEA,IAAM,MAAA,WAAA,GAAc,aAAc,CAAA,OAAA,CAAQ,WAAY,EAAA,CAAA;AAEtD,IAAM,MAAA,YAAA,GAAe,IAAK,CAAA,gBAAA,CAAiB,SAAU,EAAA,CAAA;AACrD,IAAA,MAAM,gBAAsC,EAAC,CAAA;AAE7C,IAAA,KAAA,MAAW,CAAC,GAAK,EAAA,WAAW,KAAK,MAAO,CAAA,OAAA,CAAQ,WAAW,CAAG,EAAA;AAC5D,MAAA,MAAM,SAAY,GAAA,IAAA,CAAK,aAAc,CAAA,YAAA,CAAa,KAAK,aAAa,CAAA,CAAA;AACpE,MAAM,MAAA,eAAA,GAAkB,YAAa,CAAA,MAAA,CAAO,SAAS,CAAA,CAAA;AAErD,MAAA,IAAI,CAAC,eAAA,CAAgB,eAAiB,EAAA,WAAW,CAAG,EAAA;AAClD,QAAA,aAAA,CAAc,SAAa,CAAA,GAAA,WAAA,CAAA;AAAA,OAC7B;AAAA,KACF;AAEA,IAAA,IAAI,MAAO,CAAA,IAAA,CAAK,aAAa,CAAA,CAAE,SAAS,CAAG,EAAA;AACzC,MAAA,MAAM,wBAA2B,GAAA,CAAA,EAAA,GAAA,CAAA,EAAA,GAAA,aAAA,CAAc,OAAQ,EAAA,uBAAA,KAAtB,IAAgD,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAA,CAAA,EAAA,EAAA,WAAA,CAAA,CAAA;AACjF,MAAA,MAAM,gBAAgB,wBAA6B,KAAA,IAAA,CAAA;AAEnD,MAAA,aAAA,CAAc,kBAAkB,4BAA4B,CAAA,CAAA;AAC5D,MAAK,IAAA,CAAA,gBAAA,CAAiB,OAAQ,CAAA,aAAA,EAAe,aAAa,CAAA,CAAA;AAG1D,MAAK,IAAA,CAAA,aAAA,GAAgB,IAAK,CAAA,gBAAA,CAAiB,WAAY,EAAA,CAAA;AAAA,KACzD;AAAA,GACF;AAAA,EAEO,YAAY,IAAyC,EAAA;AAC1D,IAAA,OAAO,YAAY,IAAI,CAAA,CAAA;AAAA,GACzB;AACF,CAAA;AAEA,MAAM,cAAe,CAAA;AAAA,EAIZ,YAAoB,eAAkC,EAAA;AAAlC,IAAA,IAAA,CAAA,eAAA,GAAA,eAAA,CAAA;AAH3B,IAAA,YAAA,CAAA,IAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA,CAAA;AACA,IAAA,YAAA,CAAA,IAAA,EAAA,SAAA,EAAA,KAAA,CAAA,CAAA,CAAA;AAAA,GAE8D;AAAA,EAEvD,SAA6B,GAAA;AAClC,IAAM,MAAA,QAAA,GAAW,IAAK,CAAA,eAAA,CAAgB,WAAY,EAAA,CAAA;AAElD,IAAI,IAAA,YAAA,CAAA,IAAA,EAAK,eAAc,QAAU,EAAA;AAC/B,MAAA,OAAO,YAAK,CAAA,IAAA,EAAA,MAAA,CAAA,CAAA;AAAA,KACd;AAEA,IAAA,YAAA,CAAA,IAAA,EAAK,SAAY,EAAA,QAAA,CAAA,CAAA;AACjB,IAAA,YAAA,CAAA,IAAA,EAAK,MAAS,EAAA,IAAI,eAAgB,CAAA,QAAA,CAAS,MAAM,CAAA,CAAA,CAAA;AAEjD,IAAA,OAAO,YAAK,CAAA,IAAA,EAAA,MAAA,CAAA,CAAA;AAAA,GACd;AACF,CAAA;AAjBE,MAAA,GAAA,IAAA,OAAA,EAAA,CAAA;AACA,SAAA,GAAA,IAAA,OAAA,EAAA,CAAA;AAkBF,SAAS,mBAAA,CAAoB,eAAqC,aAAgC,EAAA;AAChG,EAAA,KAAA,IAAS,OAAO,aAAe,EAAA;AAC7B,IAAI,IAAA,CAAC,gBAAgB,aAAc,CAAA,MAAA,CAAO,GAAG,CAAG,EAAA,aAAA,CAAc,IAAI,CAAG,EAAA;AACnE,MAAO,OAAA,IAAA,CAAA;AAAA,KACT;AAAA,GACF;AAEA,EAAO,OAAA,KAAA,CAAA;AACT,CAAA;AAKgB,SAAA,iBAAA,CAAkB,SAA8B,eAAsD,EAAA;AACpH,EAAO,OAAA,OAAA;AAAA,IACL,MACE,IAAI,cAAA;AAAA,MACF;AAAA,QACE,iBAAiB,OAAQ,CAAA,eAAA;AAAA,QACzB,2BAA2B,OAAQ,CAAA,yBAAA;AAAA,OACrC;AAAA,MACA,eAAA;AAAA,KACF;AAAA,IACF,CAAC,OAAA,CAAQ,eAAiB,EAAA,OAAA,CAAQ,2BAA2B,eAAe,CAAA;AAAA,GAC9E,CAAA;AACF;;;;"}

package/dist/esm/src/services/useUrlSync.js

@@ -0,0 +1,29 @@
+import { useState, useEffect } from 'react';
+import { useLocation } from 'react-router-dom';
+import { writeSceneLog } from '../utils/writeSceneLog.js';
+import { useUrlSyncManager } from './UrlSyncManager.js';
+import { useLocationServiceSafe } from '../utils/utils.js';
+
+function useUrlSync(sceneRoot, options = {}) {
+  const location = useLocation();
+  const locationService = useLocationServiceSafe();
+  const [isInitialized, setIsInitialized] = useState(false);
+  const urlSyncManager = useUrlSyncManager(options, locationService);
+  useEffect(() => {
+    urlSyncManager.initSync(sceneRoot);
+    setIsInitialized(true);
+    return () => urlSyncManager.cleanUp(sceneRoot);
+  }, [sceneRoot, urlSyncManager]);
+  useEffect(() => {
+    const latestLocation = locationService.getLocation();
+    const locationToHandle = latestLocation !== location ? latestLocation : location;
+    if (latestLocation !== location) {
+      writeSceneLog("useUrlSync", "latestLocation different from location");
+    }
+    urlSyncManager.handleNewLocation(locationToHandle);
+  }, [sceneRoot, urlSyncManager, location, locationService]);
+  return isInitialized;
+}
+
+export { useUrlSync };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/services/utils.js

@@ -0,0 +1,75 @@
+import { isEqual } from 'lodash';
+import { UniqueUrlKeyMapper } from './UniqueUrlKeyMapper.js';
+
+function getUrlState(root) {
+  const urlKeyMapper = new UniqueUrlKeyMapper();
+  const result = {};
+  const visitNode = (obj) => {
+    if (obj.urlSync) {
+      const newUrlState = obj.urlSync.getUrlState();
+      for (const [key, value] of Object.entries(newUrlState)) {
+        if (value != null) {
+          const uniqueKey = urlKeyMapper.getUniqueKey(key, obj);
+          result[uniqueKey] = value;
+        }
+      }
+    }
+    obj.forEachChild(visitNode);
+  };
+  visitNode(root);
+  return result;
+}
+function syncStateFromSearchParams(root, urlParams) {
+  const urlKeyMapper = new UniqueUrlKeyMapper();
+  syncStateFromUrl(root, urlParams, urlKeyMapper);
+}
+function syncStateFromUrl(root, urlParams, urlKeyMapper, onlyChildren) {
+  if (!onlyChildren) {
+    syncUrlStateToObject(root, urlParams, urlKeyMapper);
+  }
+  root.forEachChild((child) => {
+    syncUrlStateToObject(child, urlParams, urlKeyMapper);
+  });
+  root.forEachChild((child) => syncStateFromUrl(child, urlParams, urlKeyMapper, true));
+}
+function syncUrlStateToObject(sceneObject, urlParams, urlKeyMapper) {
+  if (sceneObject.urlSync) {
+    const urlState = {};
+    const currentState = sceneObject.urlSync.getUrlState();
+    for (const key of sceneObject.urlSync.getKeys()) {
+      const uniqueKey = urlKeyMapper.getUniqueKey(key, sceneObject);
+      const newValue = urlParams.getAll(uniqueKey);
+      const currentValue = currentState[key];
+      if (isUrlValueEqual(newValue, currentValue)) {
+        continue;
+      }
+      if (newValue.length > 0) {
+        if (Array.isArray(currentValue)) {
+          urlState[key] = newValue;
+        } else {
+          urlState[key] = newValue[0];
+        }
+      } else {
+        urlState[key] = null;
+      }
+    }
+    if (Object.keys(urlState).length > 0) {
+      sceneObject.urlSync.updateFromUrl(urlState);
+    }
+  }
+}
+function isUrlValueEqual(currentUrlValue, newUrlValue) {
+  if (currentUrlValue.length === 0 && newUrlValue == null) {
+    return true;
+  }
+  if (!Array.isArray(newUrlValue) && (currentUrlValue == null ? void 0 : currentUrlValue.length) === 1) {
+    return newUrlValue === currentUrlValue[0];
+  }
+  if ((newUrlValue == null ? void 0 : newUrlValue.length) === 0 && currentUrlValue === null) {
+    return true;
+  }
+  return isEqual(currentUrlValue, newUrlValue);
+}
+
+export { getUrlState, isUrlValueEqual, syncStateFromSearchParams, syncStateFromUrl };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"utils.js","sources":["../../../../src/services/utils.ts"],"sourcesContent":["import { isEqual } from 'lodash';\n\nimport { SceneObject, SceneObjectUrlValue, SceneObjectUrlValues } from '../core/types';\nimport { UniqueUrlKeyMapper } from './UniqueUrlKeyMapper';\n\n/**\n * @param root\n * @returns the full scene url state as a object with keys and values\n */\nexport function getUrlState(root: SceneObject): SceneObjectUrlValues {\n  const urlKeyMapper = new UniqueUrlKeyMapper();\n  const result: SceneObjectUrlValues = {};\n\n  const visitNode = (obj: SceneObject) => {\n    if (obj.urlSync) {\n      const newUrlState = obj.urlSync.getUrlState();\n\n      for (const [key, value] of Object.entries(newUrlState)) {\n        if (value != null) {\n          const uniqueKey = urlKeyMapper.getUniqueKey(key, obj);\n          result[uniqueKey] = value;\n        }\n      }\n    }\n\n    obj.forEachChild(visitNode);\n  };\n\n  visitNode(root);\n  return result;\n}\n\n/**\n * Exported util function to sync state from an initial url state.\n * Useful for initializing an embedded scenes with a url state string.\n */\nexport function syncStateFromSearchParams(root: SceneObject, urlParams: URLSearchParams) {\n  const urlKeyMapper = new UniqueUrlKeyMapper();\n  syncStateFromUrl(root, urlParams, urlKeyMapper);\n}\n\nexport function syncStateFromUrl(\n  root: SceneObject,\n  urlParams: URLSearchParams,\n  urlKeyMapper: UniqueUrlKeyMapper,\n  onlyChildren?: boolean\n) {\n  if (!onlyChildren) {\n    syncUrlStateToObject(root, urlParams, urlKeyMapper);\n  }\n\n  // These two forEachChild loops might look strange but it's to make sure we walk through the scene graph one level at a time as url key conflicts depend depth in the scene tree\n  root.forEachChild((child) => {\n    syncUrlStateToObject(child, urlParams, urlKeyMapper);\n  });\n\n  root.forEachChild((child) => syncStateFromUrl(child, urlParams, urlKeyMapper, true));\n}\n\nfunction syncUrlStateToObject(sceneObject: SceneObject, urlParams: URLSearchParams, urlKeyMapper: UniqueUrlKeyMapper) {\n  if (sceneObject.urlSync) {\n    const urlState: SceneObjectUrlValues = {};\n    const currentState = sceneObject.urlSync.getUrlState();\n\n    for (const key of sceneObject.urlSync.getKeys()) {\n      const uniqueKey = urlKeyMapper.getUniqueKey(key, sceneObject);\n      const newValue = urlParams.getAll(uniqueKey);\n      const currentValue = currentState[key];\n\n      if (isUrlValueEqual(newValue, currentValue)) {\n        continue;\n      }\n\n      if (newValue.length > 0) {\n        if (Array.isArray(currentValue)) {\n          urlState[key] = newValue;\n        } else {\n          urlState[key] = newValue[0];\n        }\n      } else {\n        // mark this key as having no url state\n        urlState[key] = null;\n      }\n    }\n\n    if (Object.keys(urlState).length > 0) {\n      sceneObject.urlSync.updateFromUrl(urlState);\n    }\n  }\n}\n\nexport function isUrlValueEqual(currentUrlValue: string[], newUrlValue: SceneObjectUrlValue): boolean {\n  if (currentUrlValue.length === 0 && newUrlValue == null) {\n    return true;\n  }\n\n  if (!Array.isArray(newUrlValue) && currentUrlValue?.length === 1) {\n    return newUrlValue === currentUrlValue[0];\n  }\n\n  if (newUrlValue?.length === 0 && currentUrlValue === null) {\n    return true;\n  }\n\n  // We have two arrays, lets compare them\n  return isEqual(currentUrlValue, newUrlValue);\n}\n"],"names":[],"mappings":";;;AASO,SAAS,YAAY,IAAyC,EAAA;AACnE,EAAM,MAAA,YAAA,GAAe,IAAI,kBAAmB,EAAA,CAAA;AAC5C,EAAA,MAAM,SAA+B,EAAC,CAAA;AAEtC,EAAM,MAAA,SAAA,GAAY,CAAC,GAAqB,KAAA;AACtC,IAAA,IAAI,IAAI,OAAS,EAAA;AACf,MAAM,MAAA,WAAA,GAAc,GAAI,CAAA,OAAA,CAAQ,WAAY,EAAA,CAAA;AAE5C,MAAA,KAAA,MAAW,CAAC,GAAK,EAAA,KAAK,KAAK,MAAO,CAAA,OAAA,CAAQ,WAAW,CAAG,EAAA;AACtD,QAAA,IAAI,SAAS,IAAM,EAAA;AACjB,UAAA,MAAM,SAAY,GAAA,YAAA,CAAa,YAAa,CAAA,GAAA,EAAK,GAAG,CAAA,CAAA;AACpD,UAAA,MAAA,CAAO,SAAa,CAAA,GAAA,KAAA,CAAA;AAAA,SACtB;AAAA,OACF;AAAA,KACF;AAEA,IAAA,GAAA,CAAI,aAAa,SAAS,CAAA,CAAA;AAAA,GAC5B,CAAA;AAEA,EAAA,SAAA,CAAU,IAAI,CAAA,CAAA;AACd,EAAO,OAAA,MAAA,CAAA;AACT,CAAA;AAMgB,SAAA,yBAAA,CAA0B,MAAmB,SAA4B,EAAA;AACvF,EAAM,MAAA,YAAA,GAAe,IAAI,kBAAmB,EAAA,CAAA;AAC5C,EAAiB,gBAAA,CAAA,IAAA,EAAM,WAAW,YAAY,CAAA,CAAA;AAChD,CAAA;AAEO,SAAS,gBACd,CAAA,IAAA,EACA,SACA,EAAA,YAAA,EACA,YACA,EAAA;AACA,EAAA,IAAI,CAAC,YAAc,EAAA;AACjB,IAAqB,oBAAA,CAAA,IAAA,EAAM,WAAW,YAAY,CAAA,CAAA;AAAA,GACpD;AAGA,EAAK,IAAA,CAAA,YAAA,CAAa,CAAC,KAAU,KAAA;AAC3B,IAAqB,oBAAA,CAAA,KAAA,EAAO,WAAW,YAAY,CAAA,CAAA;AAAA,GACpD,CAAA,CAAA;AAED,EAAK,IAAA,CAAA,YAAA,CAAa,CAAC,KAAU,KAAA,gBAAA,CAAiB,OAAO,SAAW,EAAA,YAAA,EAAc,IAAI,CAAC,CAAA,CAAA;AACrF,CAAA;AAEA,SAAS,oBAAA,CAAqB,WAA0B,EAAA,SAAA,EAA4B,YAAkC,EAAA;AACpH,EAAA,IAAI,YAAY,OAAS,EAAA;AACvB,IAAA,MAAM,WAAiC,EAAC,CAAA;AACxC,IAAM,MAAA,YAAA,GAAe,WAAY,CAAA,OAAA,CAAQ,WAAY,EAAA,CAAA;AAErD,IAAA,KAAA,MAAW,GAAO,IAAA,WAAA,CAAY,OAAQ,CAAA,OAAA,EAAW,EAAA;AAC/C,MAAA,MAAM,SAAY,GAAA,YAAA,CAAa,YAAa,CAAA,GAAA,EAAK,WAAW,CAAA,CAAA;AAC5D,MAAM,MAAA,QAAA,GAAW,SAAU,CAAA,MAAA,CAAO,SAAS,CAAA,CAAA;AAC3C,MAAA,MAAM,eAAe,YAAa,CAAA,GAAA,CAAA,CAAA;AAElC,MAAI,IAAA,eAAA,CAAgB,QAAU,EAAA,YAAY,CAAG,EAAA;AAC3C,QAAA,SAAA;AAAA,OACF;AAEA,MAAI,IAAA,QAAA,CAAS,SAAS,CAAG,EAAA;AACvB,QAAI,IAAA,KAAA,CAAM,OAAQ,CAAA,YAAY,CAAG,EAAA;AAC/B,UAAA,QAAA,CAAS,GAAO,CAAA,GAAA,QAAA,CAAA;AAAA,SACX,MAAA;AACL,UAAA,QAAA,CAAS,OAAO,QAAS,CAAA,CAAA,CAAA,CAAA;AAAA,SAC3B;AAAA,OACK,MAAA;AAEL,QAAA,QAAA,CAAS,GAAO,CAAA,GAAA,IAAA,CAAA;AAAA,OAClB;AAAA,KACF;AAEA,IAAA,IAAI,MAAO,CAAA,IAAA,CAAK,QAAQ,CAAA,CAAE,SAAS,CAAG,EAAA;AACpC,MAAY,WAAA,CAAA,OAAA,CAAQ,cAAc,QAAQ,CAAA,CAAA;AAAA,KAC5C;AAAA,GACF;AACF,CAAA;AAEgB,SAAA,eAAA,CAAgB,iBAA2B,WAA2C,EAAA;AACpG,EAAA,IAAI,eAAgB,CAAA,MAAA,KAAW,CAAK,IAAA,WAAA,IAAe,IAAM,EAAA;AACvD,IAAO,OAAA,IAAA,CAAA;AAAA,GACT;AAEA,EAAA,IAAI,CAAC,KAAM,CAAA,OAAA,CAAQ,WAAW,CAAK,IAAA,CAAA,eAAA,IAAA,IAAA,GAAA,KAAA,CAAA,GAAA,eAAA,CAAiB,YAAW,CAAG,EAAA;AAChE,IAAA,OAAO,gBAAgB,eAAgB,CAAA,CAAA,CAAA,CAAA;AAAA,GACzC;AAEA,EAAA,IAAA,CAAI,WAAa,IAAA,IAAA,GAAA,KAAA,CAAA,GAAA,WAAA,CAAA,MAAA,MAAW,CAAK,IAAA,eAAA,KAAoB,IAAM,EAAA;AACzD,IAAO,OAAA,IAAA,CAAA;AAAA,GACT;AAGA,EAAO,OAAA,OAAA,CAAQ,iBAAiB,WAAW,CAAA,CAAA;AAC7C;;;;"}

package/dist/esm/src/utils/ControlsLabel.js

@@ -0,0 +1,107 @@
+import React from 'react';
+import { useStyles2, useTheme2, Tooltip, Icon, IconButton } from '@grafana/ui';
+import { selectors } from '@grafana/e2e-selectors';
+import { css } from '@emotion/css';
+import { LoadingIndicator } from './LoadingIndicator.js';
+
+function ControlsLabel(props) {
+  const styles = useStyles2(getStyles);
+  const theme = useTheme2();
+  const isVertical = props.layout === "vertical";
+  const loadingIndicator = Boolean(props.isLoading) ? /* @__PURE__ */ React.createElement("div", {
+    style: { marginLeft: theme.spacing(1), marginTop: "-1px" },
+    "aria-label": selectors.components.LoadingIndicator.icon
+  }, /* @__PURE__ */ React.createElement(LoadingIndicator, {
+    onCancel: (e) => {
+      var _a;
+      e.preventDefault();
+      e.stopPropagation();
+      (_a = props.onCancel) == null ? void 0 : _a.call(props);
+    }
+  })) : null;
+  let errorIndicator = null;
+  if (props.error) {
+    errorIndicator = /* @__PURE__ */ React.createElement(Tooltip, {
+      content: props.error,
+      placement: "bottom"
+    }, /* @__PURE__ */ React.createElement(Icon, {
+      className: styles.errorIcon,
+      name: "exclamation-triangle"
+    }));
+  }
+  let descriptionIndicator = null;
+  if (props.description) {
+    descriptionIndicator = /* @__PURE__ */ React.createElement(Tooltip, {
+      content: props.description,
+      placement: isVertical ? "top" : "bottom"
+    }, /* @__PURE__ */ React.createElement(Icon, {
+      className: styles.normalIcon,
+      name: "info-circle"
+    }));
+  }
+  const testId = typeof props.label === "string" ? selectors.pages.Dashboard.SubMenu.submenuItemLabels(props.label) : "";
+  let labelElement;
+  if (isVertical) {
+    labelElement = /* @__PURE__ */ React.createElement("label", {
+      className: styles.verticalLabel,
+      "data-testid": testId,
+      htmlFor: props.htmlFor
+    }, props.label, descriptionIndicator, errorIndicator, props.icon && /* @__PURE__ */ React.createElement(Icon, {
+      name: props.icon,
+      className: styles.normalIcon
+    }), loadingIndicator, props.onRemove && /* @__PURE__ */ React.createElement(IconButton, {
+      variant: "secondary",
+      size: "xs",
+      name: "times",
+      onClick: props.onRemove,
+      tooltip: "Remove"
+    }));
+  } else {
+    labelElement = /* @__PURE__ */ React.createElement("label", {
+      className: styles.horizontalLabel,
+      "data-testid": testId,
+      htmlFor: props.htmlFor
+    }, errorIndicator, props.icon && /* @__PURE__ */ React.createElement(Icon, {
+      name: props.icon,
+      className: styles.normalIcon
+    }), props.label, descriptionIndicator, loadingIndicator);
+  }
+  return labelElement;
+}
+const getStyles = (theme) => ({
+  horizontalLabel: css({
+    background: theme.isDark ? theme.colors.background.primary : theme.colors.background.secondary,
+    display: `flex`,
+    alignItems: "center",
+    padding: theme.spacing(0, 1),
+    fontWeight: theme.typography.fontWeightMedium,
+    fontSize: theme.typography.bodySmall.fontSize,
+    height: theme.spacing(theme.components.height.md),
+    lineHeight: theme.spacing(theme.components.height.md),
+    borderRadius: theme.shape.borderRadius(1),
+    border: `1px solid ${theme.components.input.borderColor}`,
+    position: "relative",
+    right: -1,
+    whiteSpace: "nowrap",
+    gap: theme.spacing(0.5)
+  }),
+  verticalLabel: css({
+    display: `flex`,
+    alignItems: "center",
+    fontWeight: theme.typography.fontWeightMedium,
+    fontSize: theme.typography.bodySmall.fontSize,
+    lineHeight: theme.typography.bodySmall.lineHeight,
+    whiteSpace: "nowrap",
+    marginBottom: theme.spacing(0.5),
+    gap: theme.spacing(1)
+  }),
+  errorIcon: css({
+    color: theme.colors.error.text
+  }),
+  normalIcon: css({
+    color: theme.colors.text.secondary
+  })
+});
+
+export { ControlsLabel };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ControlsLabel.js","sources":["../../../../src/utils/ControlsLabel.tsx"],"sourcesContent":["import React from 'react';\nimport { Icon, IconButton, Tooltip, useStyles2, useTheme2 } from '@grafana/ui';\nimport { selectors } from '@grafana/e2e-selectors';\nimport { GrafanaTheme2, IconName } from '@grafana/data';\nimport { css } from '@emotion/css';\nimport { LoadingIndicator } from './LoadingIndicator';\nimport { ControlsLayout } from '../core/types';\n\ninterface ControlsLabelProps {\n  label: string;\n  htmlFor?: string;\n  description?: string;\n  isLoading?: boolean;\n  error?: string;\n  icon?: IconName;\n  layout?: ControlsLayout;\n  onCancel?: () => void;\n  onRemove?: () => void;\n}\n\nexport function ControlsLabel(props: ControlsLabelProps) {\n  const styles = useStyles2(getStyles);\n  const theme = useTheme2();\n  const isVertical = props.layout === 'vertical';\n\n  const loadingIndicator = Boolean(props.isLoading) ? (\n    <div\n      style={{ marginLeft: theme.spacing(1), marginTop: '-1px' }}\n      aria-label={selectors.components.LoadingIndicator.icon}\n    >\n      <LoadingIndicator\n        onCancel={(e) => {\n          e.preventDefault();\n          e.stopPropagation();\n          props.onCancel?.();\n        }}\n      />\n    </div>\n  ) : null;\n\n  let errorIndicator = null;\n  if (props.error) {\n    errorIndicator = (\n      <Tooltip content={props.error} placement={'bottom'}>\n        <Icon className={styles.errorIcon} name=\"exclamation-triangle\" />\n      </Tooltip>\n    );\n  }\n\n  let descriptionIndicator = null;\n  if (props.description) {\n    descriptionIndicator = (\n      <Tooltip content={props.description} placement={isVertical ? 'top' : 'bottom'}>\n        <Icon className={styles.normalIcon} name=\"info-circle\" />\n      </Tooltip>\n    );\n  }\n\n  const testId =\n    typeof props.label === 'string' ? selectors.pages.Dashboard.SubMenu.submenuItemLabels(props.label) : '';\n  let labelElement: JSX.Element;\n\n  // The vertical layout has different css class and order of elements (label always first)\n\n  if (isVertical) {\n    labelElement = (\n      <label className={styles.verticalLabel} data-testid={testId} htmlFor={props.htmlFor}>\n        {props.label}\n        {descriptionIndicator}\n        {errorIndicator}\n        {props.icon && <Icon name={props.icon} className={styles.normalIcon} />}\n        {loadingIndicator}\n        {props.onRemove && (\n          <IconButton variant=\"secondary\" size=\"xs\" name=\"times\" onClick={props.onRemove} tooltip={'Remove'} />\n        )}\n      </label>\n    );\n  } else {\n    labelElement = (\n      <label className={styles.horizontalLabel} data-testid={testId} htmlFor={props.htmlFor}>\n        {errorIndicator}\n        {props.icon && <Icon name={props.icon} className={styles.normalIcon} />}\n        {props.label}\n        {descriptionIndicator}\n        {loadingIndicator}\n      </label>\n    );\n  }\n\n  return labelElement;\n}\n\nconst getStyles = (theme: GrafanaTheme2) => ({\n  horizontalLabel: css({\n    background: theme.isDark ? theme.colors.background.primary : theme.colors.background.secondary,\n    display: `flex`,\n    alignItems: 'center',\n    padding: theme.spacing(0, 1),\n    fontWeight: theme.typography.fontWeightMedium,\n    fontSize: theme.typography.bodySmall.fontSize,\n    height: theme.spacing(theme.components.height.md),\n    lineHeight: theme.spacing(theme.components.height.md),\n    borderRadius: theme.shape.borderRadius(1),\n    border: `1px solid ${theme.components.input.borderColor}`,\n    position: 'relative',\n    // To make the border line up with the input border\n    right: -1,\n    whiteSpace: 'nowrap',\n    gap: theme.spacing(0.5),\n  }),\n  verticalLabel: css({\n    display: `flex`,\n    alignItems: 'center',\n    fontWeight: theme.typography.fontWeightMedium,\n    fontSize: theme.typography.bodySmall.fontSize,\n    lineHeight: theme.typography.bodySmall.lineHeight,\n    whiteSpace: 'nowrap',\n    marginBottom: theme.spacing(0.5),\n    gap: theme.spacing(1),\n  }),\n  errorIcon: css({\n    color: theme.colors.error.text,\n  }),\n  normalIcon: css({\n    color: theme.colors.text.secondary,\n  }),\n});\n"],"names":[],"mappings":"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"}

package/dist/esm/src/utils/LoadingIndicator.js

@@ -0,0 +1,19 @@
+import { Tooltip, Icon } from '@grafana/ui';
+import React from 'react';
+
+function LoadingIndicator(props) {
+  return /* @__PURE__ */ React.createElement(Tooltip, {
+    content: "Cancel query"
+  }, /* @__PURE__ */ React.createElement(Icon, {
+    className: "spin-clockwise",
+    name: "sync",
+    size: "xs",
+    role: "button",
+    onMouseDown: (e) => {
+      props.onCancel(e);
+    }
+  }));
+}
+
+export { LoadingIndicator };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/utils/SafeSerializableSceneObject.js

@@ -0,0 +1,39 @@
+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 _value;
+class SafeSerializableSceneObject {
+  constructor(value) {
+    __privateAdd(this, _value, void 0);
+    this.text = "__sceneObject";
+    this.valueOf = () => {
+      return __privateGet(this, _value);
+    };
+    __privateSet(this, _value, value);
+  }
+  toString() {
+    return void 0;
+  }
+  get value() {
+    return this;
+  }
+}
+_value = new WeakMap();
+
+export { SafeSerializableSceneObject };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2FmZVNlcmlhbGl6YWJsZVNjZW5lT2JqZWN0LmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvU2FmZVNlcmlhbGl6YWJsZVNjZW5lT2JqZWN0LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNjb3BlZFZhciB9IGZyb20gJ0BncmFmYW5hL2RhdGEnO1xuaW1wb3J0IHsgU2NlbmVPYmplY3QgfSBmcm9tICcuLi9jb3JlL3R5cGVzJztcblxuZXhwb3J0IGNsYXNzIFNhZmVTZXJpYWxpemFibGVTY2VuZU9iamVjdCBpbXBsZW1lbnRzIFNjb3BlZFZhciB7XG4gICN2YWx1ZTogU2NlbmVPYmplY3Q7XG5cbiAgcHVibGljIHRleHQgPSAnX19zY2VuZU9iamVjdCc7XG5cbiAgcHVibGljIGNvbnN0cnVjdG9yKHZhbHVlOiBTY2VuZU9iamVjdCkge1xuICAgIHRoaXMuI3ZhbHVlID0gdmFsdWU7XG4gIH1cblxuICBwdWJsaWMgdG9TdHJpbmcoKSB7XG4gICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgfVxuXG4gIHB1YmxpYyB2YWx1ZU9mID0gKCkgPT4ge1xuICAgIHJldHVybiB0aGlzLiN2YWx1ZTtcbiAgfTtcblxuICBwdWJsaWMgZ2V0IHZhbHVlKCkge1xuICAgIHJldHVybiB0aGlzO1xuICB9XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsSUFBQSxNQUFBLENBQUE7QUFHTyxNQUFNLDJCQUFpRCxDQUFBO0FBQUEsRUFLckQsWUFBWSxLQUFvQixFQUFBO0FBSnZDLElBQUEsWUFBQSxDQUFBLElBQUEsRUFBQSxNQUFBLEVBQUEsS0FBQSxDQUFBLENBQUEsQ0FBQTtBQUVBLElBQUEsSUFBQSxDQUFPLElBQU8sR0FBQSxlQUFBLENBQUE7QUFVZCxJQUFBLElBQUEsQ0FBTyxVQUFVLE1BQU07QUFDckIsTUFBQSxPQUFPLFlBQUssQ0FBQSxJQUFBLEVBQUEsTUFBQSxDQUFBLENBQUE7QUFBQSxLQUNkLENBQUE7QUFURSxJQUFBLFlBQUEsQ0FBQSxJQUFBLEVBQUssTUFBUyxFQUFBLEtBQUEsQ0FBQSxDQUFBO0FBQUEsR0FDaEI7QUFBQSxFQUVPLFFBQVcsR0FBQTtBQUNoQixJQUFPLE9BQUEsS0FBQSxDQUFBLENBQUE7QUFBQSxHQUNUO0FBQUEsRUFNQSxJQUFXLEtBQVEsR0FBQTtBQUNqQixJQUFPLE9BQUEsSUFBQSxDQUFBO0FBQUEsR0FDVDtBQUNGLENBQUE7QUFuQkUsTUFBQSxHQUFBLElBQUEsT0FBQSxFQUFBOzs7OyJ9

package/dist/esm/src/utils/compatibility/setWindowGrafanaSceneContext.js

@@ -0,0 +1,16 @@
+import { writeSceneLog } from '../writeSceneLog.js';
+
+function setWindowGrafanaSceneContext(activeScene) {
+  const prevScene = window.__grafanaSceneContext;
+  writeSceneLog("setWindowGrafanaScene", "set window.__grafanaSceneContext", activeScene);
+  window.__grafanaSceneContext = activeScene;
+  return () => {
+    if (window.__grafanaSceneContext === activeScene) {
+      writeSceneLog("setWindowGrafanaScene", "restore window.__grafanaSceneContext", prevScene);
+      window.__grafanaSceneContext = prevScene;
+    }
+  };
+}
+
+export { setWindowGrafanaSceneContext };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/utils/date.js

@@ -0,0 +1,15 @@
+import { isDateTime, dateMath, dateTimeParse } from '@grafana/data';
+
+function isValid(value, roundUp, timeZone) {
+  if (isDateTime(value)) {
+    return value.isValid();
+  }
+  if (dateMath.isMathString(value)) {
+    return dateMath.isValid(value);
+  }
+  const parsed = dateTimeParse(value, { roundUp, timeZone });
+  return parsed.isValid();
+}
+
+export { isValid };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL2RhdGUudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaXNEYXRlVGltZSwgZGF0ZU1hdGgsIGRhdGVUaW1lUGFyc2UgfSBmcm9tICdAZ3JhZmFuYS9kYXRhJztcbmltcG9ydCB7IFRpbWVab25lIH0gZnJvbSAnQGdyYWZhbmEvc2NoZW1hJztcblxuZXhwb3J0IGZ1bmN0aW9uIGlzVmFsaWQodmFsdWU6IHN0cmluZywgcm91bmRVcD86IGJvb2xlYW4sIHRpbWVab25lPzogVGltZVpvbmUpOiBib29sZWFuIHtcbiAgaWYgKGlzRGF0ZVRpbWUodmFsdWUpKSB7XG4gICAgcmV0dXJuIHZhbHVlLmlzVmFsaWQoKTtcbiAgfVxuXG4gIGlmIChkYXRlTWF0aC5pc01hdGhTdHJpbmcodmFsdWUpKSB7XG4gICAgcmV0dXJuIGRhdGVNYXRoLmlzVmFsaWQodmFsdWUpO1xuICB9XG5cbiAgY29uc3QgcGFyc2VkID0gZGF0ZVRpbWVQYXJzZSh2YWx1ZSwgeyByb3VuZFVwLCB0aW1lWm9uZSB9KTtcbiAgcmV0dXJuIHBhcnNlZC5pc1ZhbGlkKCk7XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHZ0IsU0FBQSxPQUFBLENBQVEsS0FBZSxFQUFBLE9BQUEsRUFBbUIsUUFBOEIsRUFBQTtBQUN0RixFQUFJLElBQUEsVUFBQSxDQUFXLEtBQUssQ0FBRyxFQUFBO0FBQ3JCLElBQUEsT0FBTyxNQUFNLE9BQVEsRUFBQSxDQUFBO0FBQUEsR0FDdkI7QUFFQSxFQUFJLElBQUEsUUFBQSxDQUFTLFlBQWEsQ0FBQSxLQUFLLENBQUcsRUFBQTtBQUNoQyxJQUFPLE9BQUEsUUFBQSxDQUFTLFFBQVEsS0FBSyxDQUFBLENBQUE7QUFBQSxHQUMvQjtBQUVBLEVBQUEsTUFBTSxTQUFTLGFBQWMsQ0FBQSxLQUFBLEVBQU8sRUFBRSxPQUFBLEVBQVMsVUFBVSxDQUFBLENBQUE7QUFDekQsRUFBQSxPQUFPLE9BQU8sT0FBUSxFQUFBLENBQUE7QUFDeEI7Ozs7In0=

package/dist/esm/src/utils/evaluateTimeRange.js

@@ -0,0 +1,16 @@
+import { dateMath } from '@grafana/data';
+
+function evaluateTimeRange(from, to, timeZone, fiscalYearStartMonth, delay) {
+  const hasDelay = delay && to === "now";
+  return {
+    from: dateMath.parse(from, false, timeZone, fiscalYearStartMonth),
+    to: dateMath.parse(hasDelay ? "now-" + delay : to, true, timeZone, fiscalYearStartMonth),
+    raw: {
+      from,
+      to
+    }
+  };
+}
+
+export { evaluateTimeRange };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZhbHVhdGVUaW1lUmFuZ2UuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlscy9ldmFsdWF0ZVRpbWVSYW5nZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBkYXRlTWF0aCwgRGF0ZVRpbWUsIFRpbWVSYW5nZSB9IGZyb20gJ0BncmFmYW5hL2RhdGEnO1xuaW1wb3J0IHsgVGltZVpvbmUgfSBmcm9tICdAZ3JhZmFuYS9zY2hlbWEnO1xuXG5leHBvcnQgZnVuY3Rpb24gZXZhbHVhdGVUaW1lUmFuZ2UoXG4gIGZyb206IHN0cmluZyB8IERhdGVUaW1lLFxuICB0bzogc3RyaW5nIHwgRGF0ZVRpbWUsXG4gIHRpbWVab25lOiBUaW1lWm9uZSxcbiAgZmlzY2FsWWVhclN0YXJ0TW9udGg/OiBudW1iZXIsXG4gIGRlbGF5Pzogc3RyaW5nXG4pOiBUaW1lUmFuZ2Uge1xuICBjb25zdCBoYXNEZWxheSA9IGRlbGF5ICYmIHRvID09PSAnbm93JztcblxuICByZXR1cm4ge1xuICAgIGZyb206IGRhdGVNYXRoLnBhcnNlKGZyb20sIGZhbHNlLCB0aW1lWm9uZSwgZmlzY2FsWWVhclN0YXJ0TW9udGgpISxcbiAgICB0bzogZGF0ZU1hdGgucGFyc2UoaGFzRGVsYXkgPyAnbm93LScgKyBkZWxheSA6IHRvLCB0cnVlLCB0aW1lWm9uZSwgZmlzY2FsWWVhclN0YXJ0TW9udGgpISxcbiAgICByYXc6IHtcbiAgICAgIGZyb206IGZyb20sXG4gICAgICB0bzogdG8sXG4gICAgfSxcbiAgfTtcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUdPLFNBQVMsaUJBQ2QsQ0FBQSxJQUFBLEVBQ0EsRUFDQSxFQUFBLFFBQUEsRUFDQSxzQkFDQSxLQUNXLEVBQUE7QUFDWCxFQUFNLE1BQUEsUUFBQSxHQUFXLFNBQVMsRUFBTyxLQUFBLEtBQUEsQ0FBQTtBQUVqQyxFQUFPLE9BQUE7QUFBQSxJQUNMLE1BQU0sUUFBUyxDQUFBLEtBQUEsQ0FBTSxJQUFNLEVBQUEsS0FBQSxFQUFPLFVBQVUsb0JBQW9CLENBQUE7QUFBQSxJQUNoRSxFQUFBLEVBQUksU0FBUyxLQUFNLENBQUEsUUFBQSxHQUFXLFNBQVMsS0FBUSxHQUFBLEVBQUEsRUFBSSxJQUFNLEVBQUEsUUFBQSxFQUFVLG9CQUFvQixDQUFBO0FBQUEsSUFDdkYsR0FBSyxFQUFBO0FBQUEsTUFDSCxJQUFBO0FBQUEsTUFDQSxFQUFBO0FBQUEsS0FDRjtBQUFBLEdBQ0YsQ0FBQTtBQUNGOzs7OyJ9

package/dist/esm/src/utils/explore.js

@@ -0,0 +1,47 @@
+import { wrapInSafeSerializableSceneObject } from './wrapInSafeSerializableSceneObject.js';
+import { getDataSourceSrv } from '@grafana/runtime';
+
+async function getExploreURL(data, model, timeRange, transform) {
+  var _a, _b, _c, _d;
+  const targets = (_a = data.request) == null ? void 0 : _a.targets;
+  if (!targets) {
+    return "";
+  }
+  const { from, to } = timeRange;
+  const filters = (_b = data.request) == null ? void 0 : _b.filters;
+  const scopedVars = {
+    __sceneObject: wrapInSafeSerializableSceneObject(model)
+  };
+  const interpolatedQueries = (await Promise.allSettled(
+    targets.map(async (q) => {
+      var _a2;
+      const queryDs = await getDataSourceSrv().get(q.datasource);
+      return ((_a2 = queryDs.interpolateVariablesInQueries) == null ? void 0 : _a2.call(queryDs, [q], scopedVars != null ? scopedVars : {}, filters)[0]) || q;
+    })
+  )).filter((promise) => promise.status === "fulfilled").map((q) => q.value).map((q) => {
+    var _a2;
+    return (_a2 = transform == null ? void 0 : transform(q)) != null ? _a2 : q;
+  });
+  const queries = interpolatedQueries != null ? interpolatedQueries : [];
+  const datasource = (_d = (_c = queries.find((query) => {
+    var _a2;
+    return !!((_a2 = query.datasource) == null ? void 0 : _a2.uid);
+  })) == null ? void 0 : _c.datasource) == null ? void 0 : _d.uid;
+  if ((queries == null ? void 0 : queries.length) && datasource && from && to) {
+    const left = encodeURIComponent(
+      JSON.stringify({
+        datasource,
+        queries,
+        range: {
+          from,
+          to
+        }
+      })
+    );
+    return `/explore?left=${left}`;
+  }
+  return "";
+}
+
+export { getExploreURL };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/utils/getCompareSeriesRefId.js

@@ -0,0 +1,4 @@
+const getCompareSeriesRefId = (refId) => `${refId}-compare`;
+
+export { getCompareSeriesRefId };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0Q29tcGFyZVNlcmllc1JlZklkLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvZ2V0Q29tcGFyZVNlcmllc1JlZklkLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBnZXRDb21wYXJlU2VyaWVzUmVmSWQgPSAocmVmSWQ6IHN0cmluZykgPT4gYCR7cmVmSWR9LWNvbXBhcmVgO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFhLE1BQUEscUJBQUEsR0FBd0IsQ0FBQyxLQUFBLEtBQWtCLENBQUcsRUFBQSxLQUFBLENBQUEsUUFBQTs7OzsifQ==