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

package/dist/esm/dist/esm/services/SceneObjectUrlSyncConfig.js

@@ -0,0 +1,30 @@
+class SceneObjectUrlSyncConfig {
+  constructor(_sceneObject, _options) {
+    this._sceneObject = _sceneObject;
+    this._nextChangeShouldAddHistoryStep = false;
+    this._keys = _options.keys;
+  }
+  getKeys() {
+    if (typeof this._keys === "function") {
+      return this._keys();
+    }
+    return this._keys;
+  }
+  getUrlState() {
+    return this._sceneObject.getUrlState();
+  }
+  updateFromUrl(values) {
+    this._sceneObject.updateFromUrl(values);
+  }
+  performBrowserHistoryAction(callback) {
+    this._nextChangeShouldAddHistoryStep = true;
+    callback();
+    this._nextChangeShouldAddHistoryStep = false;
+  }
+  shouldCreateHistoryStep(values) {
+    return this._nextChangeShouldAddHistoryStep;
+  }
+}
+
+export { SceneObjectUrlSyncConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/dist/esm/services/UniqueUrlKeyMapper.js

@@ -0,0 +1,45 @@
+import { sceneGraph } from '../core/sceneGraph/index.js';
+
+class UniqueUrlKeyMapper {
+  constructor() {
+    this.index = /* @__PURE__ */ new Map();
+  }
+  getUniqueKey(key, obj) {
+    const objectsWithKey = this.index.get(key);
+    if (!objectsWithKey) {
+      this.index.set(key, [obj]);
+      return key;
+    }
+    let address = objectsWithKey.findIndex((o) => o === obj);
+    if (address === -1) {
+      filterOutOrphanedObjects(objectsWithKey);
+      objectsWithKey.push(obj);
+      address = objectsWithKey.length - 1;
+    }
+    if (address > 0) {
+      return `${key}-${address + 1}`;
+    }
+    return key;
+  }
+  clear() {
+    this.index.clear();
+  }
+}
+function filterOutOrphanedObjects(sceneObjects) {
+  for (const obj of sceneObjects) {
+    if (isOrphanOrInActive(obj)) {
+      const index = sceneObjects.indexOf(obj);
+      sceneObjects.splice(index, 1);
+    }
+  }
+}
+function isOrphanOrInActive(obj) {
+  const root = obj.getRoot();
+  if (!sceneGraph.findObject(root, (child) => child === obj)) {
+    return true;
+  }
+  return false;
+}
+
+export { UniqueUrlKeyMapper };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"UniqueUrlKeyMapper.js","sources":["../../../services/UniqueUrlKeyMapper.js"],"sourcesContent":["import { sceneGraph } from '../core/sceneGraph/index.js';\n\nclass UniqueUrlKeyMapper {\n  constructor() {\n    this.index = /* @__PURE__ */ new Map();\n  }\n  getUniqueKey(key, obj) {\n    const objectsWithKey = this.index.get(key);\n    if (!objectsWithKey) {\n      this.index.set(key, [obj]);\n      return key;\n    }\n    let address = objectsWithKey.findIndex((o) => o === obj);\n    if (address === -1) {\n      filterOutOrphanedObjects(objectsWithKey);\n      objectsWithKey.push(obj);\n      address = objectsWithKey.length - 1;\n    }\n    if (address > 0) {\n      return `${key}-${address + 1}`;\n    }\n    return key;\n  }\n  clear() {\n    this.index.clear();\n  }\n}\nfunction filterOutOrphanedObjects(sceneObjects) {\n  for (const obj of sceneObjects) {\n    if (isOrphanOrInActive(obj)) {\n      const index = sceneObjects.indexOf(obj);\n      sceneObjects.splice(index, 1);\n    }\n  }\n}\nfunction isOrphanOrInActive(obj) {\n  const root = obj.getRoot();\n  if (!sceneGraph.findObject(root, (child) => child === obj)) {\n    return true;\n  }\n  return false;\n}\n\nexport { UniqueUrlKeyMapper };\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n"],"names":[],"mappings":";;AAQO,MAAM,kBAAmB,CAAA;EAAzB,WAAA,GAAA;AACG,IAAA,IAAA,CAAA,KAAA,uBAAY,GAA2B,EAAA,CAAA;AAAA,GAAA;AAExC,EAAA,YAAA,CAAa,KAAa,GAAkB,EAAA;AACjD,IAAA,MAAM,cAAiB,GAAA,IAAA,CAAK,KAAM,CAAA,GAAA,CAAI,GAAG,CAAA,CAAA;AAEzC,IAAA,IAAI,CAAC,cAAgB,EAAA;AACnB,MAAA,IAAA,CAAK,KAAM,CAAA,GAAA,CAAI,GAAK,EAAA,CAAC,GAAG,CAAC,CAAA,CAAA;AAClB,MAAA,OAAA,GAAA,CAAA;AAAA,KAAA;AAGT,IAAA,IAAI,UAAU,cAAe,CAAA,SAAA,CAAU,CAAC,CAAA,KAAM,MAAM,GAAG,CAAA,CAAA;AACvD,IAAA,IAAI,YAAY,CAAI,CAAA,EAAA;AAClB,MAAA,wBAAA,CAAyB,cAAc,CAAA,CAAA;AACvC,MAAA,cAAA,CAAe,KAAK,GAAG,CAAA,CAAA;AAEvB,MAAA,OAAA,GAAU,eAAe,MAAS,GAAA,CAAA,CAAA;AAAA,KAAA;AAGpC,IAAA,IAAI,UAAU,CAAG,EAAA;AACR,MAAA,OAAA,CAAA,EAAG,OAAO,OAAU,GAAA,CAAA,CAAA,CAAA,CAAA;AAAA,KAAA;AAGtB,IAAA,OAAA,GAAA,CAAA;AAAA,GAAA;EAGF,KAAQ,GAAA;AACb,IAAA,IAAA,CAAK,MAAM,KAAM,EAAA,CAAA;AAAA,GAAA;AAErB,CAAA;AAEA,SAAS,yBAAyB,YAA6B,EAAA;AAC7D,EAAA,KAAA,MAAW,OAAO,YAAc,EAAA;AAC1B,IAAA,IAAA,kBAAA,CAAmB,GAAG,CAAG,EAAA;AACrB,MAAA,MAAA,KAAA,GAAQ,YAAa,CAAA,OAAA,CAAQ,GAAG,CAAA,CAAA;AACzB,MAAA,YAAA,CAAA,MAAA,CAAO,OAAO,CAAC,CAAA,CAAA;AAAA,KAAA;AAC9B,GAAA;AAEJ,CAAA;AAEA,SAAS,mBAAmB,GAAkB,EAAA;AACtC,EAAA,MAAA,IAAA,GAAO,IAAI,OAAQ,EAAA,CAAA;AAGrB,EAAA,IAAA,CAAC,WAAW,UAAW,CAAA,IAAA,EAAM,CAAC,KAAU,KAAA,KAAA,KAAU,GAAG,CAAG,EAAA;AACnD,IAAA,OAAA,IAAA,CAAA;AAAA,GAAA;AAGF,EAAA,OAAA,KAAA,CAAA;AACT;;;;"}

package/dist/esm/dist/esm/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(locationService2) {
+    this.locationService = locationService2;
+    __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 = /* @__PURE__ */ new WeakMap();
+_location = /* @__PURE__ */ 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, locationService2) {
+  return useMemo(
+    () => new UrlSyncManager(
+      {
+        updateUrlOnInit: options.updateUrlOnInit,
+        createBrowserHistorySteps: options.createBrowserHistorySteps
+      },
+      locationService2
+    ),
+    [options.updateUrlOnInit, options.createBrowserHistorySteps, locationService2]
+  );
+}
+
+export { NewSceneObjectAddedEvent, UrlSyncManager, useUrlSyncManager };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"UrlSyncManager.js","sources":["../../../services/UrlSyncManager.js"],"sourcesContent":["import { locationService } from '@grafana/runtime';\nimport { SceneObjectStateChangedEvent } from '../core/events.js';\nimport { writeSceneLog } from '../utils/writeSceneLog.js';\nimport { Subscription } from 'rxjs';\nimport { UniqueUrlKeyMapper } from './UniqueUrlKeyMapper.js';\nimport { getUrlState, syncStateFromUrl, isUrlValueEqual } from './utils.js';\nimport { BusEventWithPayload } from '@grafana/data';\nimport { useMemo } from 'react';\n\nvar __accessCheck = (obj, member, msg) => {\n  if (!member.has(obj))\n    throw TypeError(\"Cannot \" + msg);\n};\nvar __privateGet = (obj, member, getter) => {\n  __accessCheck(obj, member, \"read from private field\");\n  return getter ? getter.call(obj) : member.get(obj);\n};\nvar __privateAdd = (obj, member, value) => {\n  if (member.has(obj))\n    throw TypeError(\"Cannot add the same private member more than once\");\n  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);\n};\nvar __privateSet = (obj, member, value, setter) => {\n  __accessCheck(obj, member, \"write to private field\");\n  setter ? setter.call(obj, value) : member.set(obj, value);\n  return value;\n};\nvar _cache, _location;\nclass NewSceneObjectAddedEvent extends BusEventWithPayload {\n}\nNewSceneObjectAddedEvent.type = \"new-scene-object-added\";\nclass UrlSyncManager {\n  constructor(_options = {}, locationService$1 = locationService) {\n    this._urlKeyMapper = new UniqueUrlKeyMapper();\n    this._options = _options;\n    this._locationService = locationService$1;\n    this._paramsCache = new UrlParamsCache(locationService$1);\n  }\n  initSync(root) {\n    var _a;\n    if (this._subs) {\n      writeSceneLog(\"UrlSyncManager\", \"Unregister previous scene state subscription\", (_a = this._sceneRoot) == null ? void 0 : _a.state.key);\n      this._subs.unsubscribe();\n    }\n    writeSceneLog(\"UrlSyncManager\", \"init\", root.state.key);\n    this._sceneRoot = root;\n    this._subs = new Subscription();\n    this._subs.add(\n      root.subscribeToEvent(SceneObjectStateChangedEvent, (evt) => {\n        this.handleSceneObjectStateChanged(evt.payload.changedObject);\n      })\n    );\n    this._subs.add(\n      root.subscribeToEvent(NewSceneObjectAddedEvent, (evt) => {\n        this.handleNewObject(evt.payload);\n      })\n    );\n    this._urlKeyMapper.clear();\n    this._lastLocation = this._locationService.getLocation();\n    this.handleNewObject(this._sceneRoot);\n    if (this._options.updateUrlOnInit) {\n      const urlState = getUrlState(root);\n      if (isUrlStateDifferent(urlState, this._paramsCache.getParams())) {\n        this._locationService.partial(urlState, true);\n      }\n    }\n  }\n  cleanUp(root) {\n    if (this._sceneRoot !== root) {\n      return;\n    }\n    writeSceneLog(\"UrlSyncManager\", \"Clean up\");\n    if (this._subs) {\n      this._subs.unsubscribe();\n      this._subs = void 0;\n      writeSceneLog(\n        \"UrlSyncManager\",\n        \"Root deactived, unsub to state\",\n        \"same key\",\n        this._sceneRoot.state.key === root.state.key\n      );\n    }\n    this._sceneRoot = void 0;\n    this._lastLocation = void 0;\n  }\n  handleNewLocation(location) {\n    if (!this._sceneRoot || this._lastLocation === location) {\n      return;\n    }\n    writeSceneLog(\"UrlSyncManager\", \"handleNewLocation\");\n    this._lastLocation = location;\n    syncStateFromUrl(this._sceneRoot, this._paramsCache.getParams(), this._urlKeyMapper);\n  }\n  handleNewObject(sceneObj) {\n    if (!this._sceneRoot) {\n      return;\n    }\n    syncStateFromUrl(sceneObj, this._paramsCache.getParams(), this._urlKeyMapper);\n  }\n  handleSceneObjectStateChanged(changedObject) {\n    var _a, _b;\n    if (!changedObject.urlSync) {\n      return;\n    }\n    const newUrlState = changedObject.urlSync.getUrlState();\n    const searchParams = this._locationService.getSearch();\n    const mappedUpdated = {};\n    for (const [key, newUrlValue] of Object.entries(newUrlState)) {\n      const uniqueKey = this._urlKeyMapper.getUniqueKey(key, changedObject);\n      const currentUrlValue = searchParams.getAll(uniqueKey);\n      if (!isUrlValueEqual(currentUrlValue, newUrlValue)) {\n        mappedUpdated[uniqueKey] = newUrlValue;\n      }\n    }\n    if (Object.keys(mappedUpdated).length > 0) {\n      const shouldCreateHistoryEntry = (_b = (_a = changedObject.urlSync).shouldCreateHistoryStep) == null ? void 0 : _b.call(_a, newUrlState);\n      const shouldReplace = shouldCreateHistoryEntry !== true;\n      writeSceneLog(\"UrlSyncManager\", \"onStateChange updating URL\");\n      this._locationService.partial(mappedUpdated, shouldReplace);\n      this._lastLocation = this._locationService.getLocation();\n    }\n  }\n  getUrlState(root) {\n    return getUrlState(root);\n  }\n}\nclass UrlParamsCache {\n  constructor(locationService) {\n    this.locationService = locationService;\n    __privateAdd(this, _cache, void 0);\n    __privateAdd(this, _location, void 0);\n  }\n  getParams() {\n    const location = this.locationService.getLocation();\n    if (__privateGet(this, _location) === location) {\n      return __privateGet(this, _cache);\n    }\n    __privateSet(this, _location, location);\n    __privateSet(this, _cache, new URLSearchParams(location.search));\n    return __privateGet(this, _cache);\n  }\n}\n_cache = new WeakMap();\n_location = new WeakMap();\nfunction isUrlStateDifferent(sceneUrlState, currentParams) {\n  for (let key in sceneUrlState) {\n    if (!isUrlValueEqual(currentParams.getAll(key), sceneUrlState[key])) {\n      return true;\n    }\n  }\n  return false;\n}\nfunction useUrlSyncManager(options, locationService) {\n  return useMemo(\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\nexport { NewSceneObjectAddedEvent, UrlSyncManager, useUrlSyncManager };\n//# 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":"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"}\n"],"names":["locationService","locationServiceRuntime"],"mappings":"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"}

package/dist/esm/dist/esm/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/dist/esm/services/utils.js

@@ -0,0 +1,71 @@
+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 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, syncStateFromUrl };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"utils.js","sources":["../../../services/utils.js"],"sourcesContent":["import { isEqual } from 'lodash';\nimport { UniqueUrlKeyMapper } from './UniqueUrlKeyMapper.js';\n\nfunction getUrlState(root) {\n  const urlKeyMapper = new UniqueUrlKeyMapper();\n  const result = {};\n  const visitNode = (obj) => {\n    if (obj.urlSync) {\n      const newUrlState = obj.urlSync.getUrlState();\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    obj.forEachChild(visitNode);\n  };\n  visitNode(root);\n  return result;\n}\nfunction syncStateFromSearchParams(root, urlParams) {\n  const urlKeyMapper = new UniqueUrlKeyMapper();\n  syncStateFromUrl(root, urlParams, urlKeyMapper);\n}\nfunction syncStateFromUrl(root, urlParams, urlKeyMapper, onlyChildren) {\n  if (!onlyChildren) {\n    syncUrlStateToObject(root, urlParams, urlKeyMapper);\n  }\n  root.forEachChild((child) => {\n    syncUrlStateToObject(child, urlParams, urlKeyMapper);\n  });\n  root.forEachChild((child) => syncStateFromUrl(child, urlParams, urlKeyMapper, true));\n}\nfunction syncUrlStateToObject(sceneObject, urlParams, urlKeyMapper) {\n  if (sceneObject.urlSync) {\n    const urlState = {};\n    const currentState = sceneObject.urlSync.getUrlState();\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      if (isUrlValueEqual(newValue, currentValue)) {\n        continue;\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        urlState[key] = null;\n      }\n    }\n    if (Object.keys(urlState).length > 0) {\n      sceneObject.urlSync.updateFromUrl(urlState);\n    }\n  }\n}\nfunction isUrlValueEqual(currentUrlValue, newUrlValue) {\n  if (currentUrlValue.length === 0 && newUrlValue == null) {\n    return true;\n  }\n  if (!Array.isArray(newUrlValue) && (currentUrlValue == null ? void 0 : currentUrlValue.length) === 1) {\n    return newUrlValue === currentUrlValue[0];\n  }\n  if ((newUrlValue == null ? void 0 : newUrlValue.length) === 0 && currentUrlValue === null) {\n    return true;\n  }\n  return isEqual(currentUrlValue, newUrlValue);\n}\n\nexport { getUrlState, isUrlValueEqual, syncStateFromSearchParams, syncStateFromUrl };\n//# 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":"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"}\n"],"names":[],"mappings":";;;AASO,SAAS,YAAY,IAAyC,EAAA;AAC7D,EAAA,MAAA,YAAA,GAAe,IAAI,kBAAmB,EAAA,CAAA;AAC5C,EAAA,MAAM,SAA+B,EAAA,CAAA;AAE/B,EAAA,MAAA,SAAA,GAAY,CAAC,GAAqB,KAAA;AACtC,IAAA,IAAI,IAAI,OAAS,EAAA;AACT,MAAA,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,SAAA;AACtB,OAAA;AACF,KAAA;AAGF,IAAA,GAAA,CAAI,aAAa,SAAS,CAAA,CAAA;AAAA,GAAA,CAAA;AAG5B,EAAA,SAAA,CAAU,IAAI,CAAA,CAAA;AACP,EAAA,OAAA,MAAA,CAAA;AACT,CAAA;AAWO,SAAS,gBACd,CAAA,IAAA,EACA,SACA,EAAA,YAAA,EACA,YACA,EAAA;AACA,EAAA,IAAI,CAAC,YAAc,EAAA;AACI,IAAA,oBAAA,CAAA,IAAA,EAAM,WAAW,YAAY,CAAA,CAAA;AAAA,GAAA;AAI/C,EAAA,IAAA,CAAA,YAAA,CAAa,CAAC,KAAU,KAAA;AACN,IAAA,oBAAA,CAAA,KAAA,EAAO,WAAW,YAAY,CAAA,CAAA;GACpD,CAAA,CAAA;AAEI,EAAA,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,EAAA,CAAA;AACjC,IAAA,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;AACtD,MAAA,MAAA,QAAA,GAAW,SAAU,CAAA,MAAA,CAAO,SAAS,CAAA,CAAA;AAC3C,MAAA,MAAM,eAAe,YAAa,CAAA,GAAA,CAAA,CAAA;AAE9B,MAAA,IAAA,eAAA,CAAgB,QAAU,EAAA,YAAY,CAAG,EAAA;AAC3C,QAAA,SAAA;AAAA,OAAA;AAGE,MAAA,IAAA,QAAA,CAAS,SAAS,CAAG,EAAA;AACnB,QAAA,IAAA,KAAA,CAAM,OAAQ,CAAA,YAAY,CAAG,EAAA;AAC/B,UAAA,QAAA,CAAS,GAAO,CAAA,GAAA,QAAA,CAAA;SACX,MAAA;AACL,UAAA,QAAA,CAAS,OAAO,QAAS,CAAA,CAAA,CAAA,CAAA;AAAA,SAAA;OAEtB,MAAA;AAEL,QAAA,QAAA,CAAS,GAAO,CAAA,GAAA,IAAA,CAAA;AAAA,OAAA;AAClB,KAAA;AAGF,IAAA,IAAI,MAAO,CAAA,IAAA,CAAK,QAAQ,CAAA,CAAE,SAAS,CAAG,EAAA;AACxB,MAAA,WAAA,CAAA,OAAA,CAAQ,cAAc,QAAQ,CAAA,CAAA;AAAA,KAAA;AAC5C,GAAA;AAEJ,CAAA;AAEgB,SAAA,eAAA,CAAgB,iBAA2B,WAA2C,EAAA;AACpG,EAAA,IAAI,eAAgB,CAAA,MAAA,KAAW,CAAK,IAAA,WAAA,IAAe,IAAM,EAAA;AAChD,IAAA,OAAA,IAAA,CAAA;AAAA,GAAA;AAGT,EAAI,IAAA,CAAC,KAAM,CAAA,OAAA,CAAQ,WAAW,CAAA,IAAA,CAAK,mBAAA,IAAA,GAAA,KAAA,CAAA,GAAA,eAAiB,CAAA,MAAA,MAAW,CAAG,EAAA;AAChE,IAAA,OAAO,gBAAgB,eAAgB,CAAA,CAAA,CAAA,CAAA;AAAA,GAAA;AAGzC,EAAA,IAAA,CAAI,eAAa,IAAA,GAAA,KAAA,CAAA,GAAA,YAAA,MAAW,MAAA,CAAA,IAAK,oBAAoB,IAAM,EAAA;AAClD,IAAA,OAAA,IAAA,CAAA;AAAA,GAAA;AAIF,EAAA,OAAA,OAAA,CAAQ,iBAAiB,WAAW,CAAA,CAAA;AAC7C;;;;"}