dara-core 1.13.0__py3-none-any.whl → 1.14.0a0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. dara/core/auth/base.py +10 -1
  2. dara/core/auth/routes.py +51 -1
  3. dara/core/interactivity/data_variable.py +7 -0
  4. dara/core/interactivity/derived_data_variable.py +7 -0
  5. dara/core/internal/routing.py +2 -0
  6. dara/core/umd/dara.core.umd.js +722 -778
  7. {dara_core-1.13.0.dist-info → dara_core-1.14.0a0.dist-info}/METADATA +25 -10
  8. {dara_core-1.13.0.dist-info → dara_core-1.14.0a0.dist-info}/RECORD +11 -11
  9. {dara_core-1.13.0.dist-info → dara_core-1.14.0a0.dist-info}/LICENSE +0 -0
  10. {dara_core-1.13.0.dist-info → dara_core-1.14.0a0.dist-info}/WHEEL +0 -0
  11. {dara_core-1.13.0.dist-info → dara_core-1.14.0a0.dist-info}/entry_points.txt +0 -0
dara/core/umd/dara.core.umd.js CHANGED
@@ -30,10 +30,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
30
30
  return __privateGet(obj, member, getter);
31
31
  }
32
32
  });
33
+ var __privateMethod = (obj, member, method) => {
34
+ __accessCheck(obj, member, "access private method");
35
+ return method;
36
+ };
33
37
  (function(global2, factory) {
34
38
  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("react"), require("@tanstack/react-query"), require("react-dom"), require("styled-components")) : typeof define === "function" && define.amd ? define(["exports", "react", "@tanstack/react-query", "react-dom", "styled-components"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory((global2.dara = global2.dara || {}, global2.dara.core = {}), global2.React, global2.ReactQuery, global2.ReactDOM, global2.styled));
35
39
  })(this, function(exports, React, reactQuery, ReactDOM, styled) {
36
- var _pingInterval, _socketUrl, _reconnectCount, _events$, _parentBus, _instance, _observers;
40
+ var _state, _locks, _subscribers, _notify, notify_fn, _pingInterval, _socketUrl, _reconnectCount, _events$, _parentBus, _instance, _observers;
37
41
  "use strict";
38
42
  const _interopDefaultLegacy = (e3) => e3 && typeof e3 === "object" && "default" in e3 ? e3 : { default: e3 };
39
43
  function _interopNamespace(e3) {
@@ -874,9 +878,6 @@ var __privateWrapper = (obj, member, setter, getter) => ({
874
878
  return history2;
875
879
  }
876
880
  var commonjsGlobal$1 = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
877
- function getDefaultExportFromCjs(x2) {
878
- return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
879
- }
880
881
  var createRoot;
881
882
  var m$3 = ReactDOM__default.default;
882
883
  {
@@ -989,8 +990,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
989
990
  var partial = prefix2 != null && next != null && next !== prefix2;
990
991
  var repeat = modifier === "+" || modifier === "*";
991
992
  var optional2 = modifier === "?" || modifier === "*";
992
- var delimiter = res[2] || defaultDelimiter;
993
+ var delimiter = prefix2 || defaultDelimiter;
993
994
  var pattern = capture || group;
995
+ var prevText = prefix2 || (typeof tokens[tokens.length - 1] === "string" ? tokens[tokens.length - 1] : "");
994
996
  tokens.push({
995
997
  name: name || key++,
996
998
  prefix: prefix2 || "",
@@ -999,7 +1001,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
999
1001
  repeat,
1000
1002
  partial,
1001
1003
  asterisk: !!asterisk,
1002
- pattern: pattern ? escapeGroup(pattern) : asterisk ? ".*" : "[^" + escapeString(delimiter) + "]+?"
1004
+ pattern: pattern ? escapeGroup(pattern) : asterisk ? ".*" : restrictBacktrack(delimiter, prevText)
1003
1005
  });
1004
1006
  }
1005
1007
  if (index2 < str.length) {
@@ -1010,6 +1012,12 @@ var __privateWrapper = (obj, member, setter, getter) => ({
1010
1012
  }
1011
1013
  return tokens;
1012
1014
  }
1015
+ function restrictBacktrack(delimiter, prevText) {
1016
+ if (!prevText || prevText.indexOf(delimiter) > -1) {
1017
+ return "[^" + escapeString(delimiter) + "]+?";
1018
+ }
1019
+ return escapeString(prevText) + "|(?:(?!" + escapeString(prevText) + ")[^" + escapeString(delimiter) + "])+?";
1020
+ }
1013
1021
  function compile(str, options) {
1014
1022
  return tokensToFunction(parse$3(str, options), options);
1015
1023
  }
@@ -1291,7 +1299,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
1291
1299
  var t2 = {};
1292
1300
  for (var n2 in r2)
1293
1301
  if ({}.hasOwnProperty.call(r2, n2)) {
1294
- if (e3.indexOf(n2) >= 0)
1302
+ if (e3.includes(n2))
1295
1303
  continue;
1296
1304
  t2[n2] = r2[n2];
1297
1305
  }
@@ -3377,22 +3385,22 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3377
3385
  }
3378
3386
  }
3379
3387
  }
3380
- function saveDepsToStore(key, deps, store, version2) {
3388
+ function saveDepsToStore(key, deps, store2, version) {
3381
3389
  var _storeState$nextTree, _storeState$previousT, _storeState$previousT2, _storeState$previousT3;
3382
- const storeState = store.getState();
3383
- if (!(version2 === storeState.currentTree.version || version2 === ((_storeState$nextTree = storeState.nextTree) === null || _storeState$nextTree === void 0 ? void 0 : _storeState$nextTree.version) || version2 === ((_storeState$previousT = storeState.previousTree) === null || _storeState$previousT === void 0 ? void 0 : _storeState$previousT.version)))
3390
+ const storeState = store2.getState();
3391
+ if (!(version === storeState.currentTree.version || version === ((_storeState$nextTree = storeState.nextTree) === null || _storeState$nextTree === void 0 ? void 0 : _storeState$nextTree.version) || version === ((_storeState$previousT = storeState.previousTree) === null || _storeState$previousT === void 0 ? void 0 : _storeState$previousT.version)))
3384
3392
  ;
3385
- const graph2 = store.getGraph(version2);
3393
+ const graph2 = store2.getGraph(version);
3386
3394
  mergeDepsIntoGraph(key, deps, graph2);
3387
- if (version2 === ((_storeState$previousT2 = storeState.previousTree) === null || _storeState$previousT2 === void 0 ? void 0 : _storeState$previousT2.version)) {
3388
- const currentGraph = store.getGraph(storeState.currentTree.version);
3395
+ if (version === ((_storeState$previousT2 = storeState.previousTree) === null || _storeState$previousT2 === void 0 ? void 0 : _storeState$previousT2.version)) {
3396
+ const currentGraph = store2.getGraph(storeState.currentTree.version);
3389
3397
  mergeDepsIntoGraph(key, deps, currentGraph, graph2);
3390
3398
  }
3391
- if (version2 === ((_storeState$previousT3 = storeState.previousTree) === null || _storeState$previousT3 === void 0 ? void 0 : _storeState$previousT3.version) || version2 === storeState.currentTree.version) {
3399
+ if (version === ((_storeState$previousT3 = storeState.previousTree) === null || _storeState$previousT3 === void 0 ? void 0 : _storeState$previousT3.version) || version === storeState.currentTree.version) {
3392
3400
  var _storeState$nextTree2;
3393
3401
  const nextVersion = (_storeState$nextTree2 = storeState.nextTree) === null || _storeState$nextTree2 === void 0 ? void 0 : _storeState$nextTree2.version;
3394
3402
  if (nextVersion !== void 0) {
3395
- const nextGraph = store.getGraph(nextVersion);
3403
+ const nextGraph = store2.getGraph(nextVersion);
3396
3404
  mergeDepsIntoGraph(key, deps, nextGraph, graph2);
3397
3405
  }
3398
3406
  }
@@ -3423,10 +3431,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3423
3431
  getNextTreeStateVersion: getNextTreeStateVersion$1
3424
3432
  } = Recoil_Keys;
3425
3433
  function makeEmptyTreeState() {
3426
- const version2 = getNextTreeStateVersion$1();
3434
+ const version = getNextTreeStateVersion$1();
3427
3435
  return {
3428
- version: version2,
3429
- stateID: version2,
3436
+ version,
3437
+ stateID: version,
3430
3438
  transactionMetadata: {},
3431
3439
  dirtyAtoms: /* @__PURE__ */ new Set(),
3432
3440
  atomValues: persistentMap$1(),
@@ -3546,13 +3554,13 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3546
3554
  const emptySet = Object.freeze(/* @__PURE__ */ new Set());
3547
3555
  class ReadOnlyRecoilValueError extends Error {
3548
3556
  }
3549
- function initializeRetentionForNode(store, nodeKey, retainedBy) {
3557
+ function initializeRetentionForNode(store2, nodeKey, retainedBy) {
3550
3558
  if (!Recoil_gkx("recoil_memory_managament_2020")) {
3551
3559
  return () => void 0;
3552
3560
  }
3553
3561
  const {
3554
3562
  nodesRetainedByZone: nodesRetainedByZone2
3555
- } = store.getState().retention;
3563
+ } = store2.getState().retention;
3556
3564
  function addToZone(zone) {
3557
3565
  let set2 = nodesRetainedByZone2.get(zone);
3558
3566
  if (!set2) {
@@ -3573,7 +3581,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3573
3581
  }
3574
3582
  const {
3575
3583
  retention
3576
- } = store.getState();
3584
+ } = store2.getState();
3577
3585
  function deleteFromZone(zone) {
3578
3586
  const set2 = retention.nodesRetainedByZone.get(zone);
3579
3587
  set2 === null || set2 === void 0 ? void 0 : set2.delete(nodeKey);
@@ -3590,34 +3598,34 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3590
3598
  }
3591
3599
  };
3592
3600
  }
3593
- function initializeNodeIfNewToStore(store, treeState, key, trigger) {
3594
- const storeState = store.getState();
3601
+ function initializeNodeIfNewToStore(store2, treeState, key, trigger) {
3602
+ const storeState = store2.getState();
3595
3603
  if (storeState.nodeCleanupFunctions.has(key)) {
3596
3604
  return;
3597
3605
  }
3598
3606
  const node = getNode$1(key);
3599
- const retentionCleanup = initializeRetentionForNode(store, key, node.retainedBy);
3600
- const nodeCleanup = node.init(store, treeState, trigger);
3607
+ const retentionCleanup = initializeRetentionForNode(store2, key, node.retainedBy);
3608
+ const nodeCleanup = node.init(store2, treeState, trigger);
3601
3609
  storeState.nodeCleanupFunctions.set(key, () => {
3602
3610
  nodeCleanup();
3603
3611
  retentionCleanup();
3604
3612
  });
3605
3613
  }
3606
- function initializeNode(store, key, trigger) {
3607
- initializeNodeIfNewToStore(store, store.getState().currentTree, key, trigger);
3614
+ function initializeNode(store2, key, trigger) {
3615
+ initializeNodeIfNewToStore(store2, store2.getState().currentTree, key, trigger);
3608
3616
  }
3609
- function cleanUpNode(store, key) {
3617
+ function cleanUpNode(store2, key) {
3610
3618
  var _state$nodeCleanupFun;
3611
- const state = store.getState();
3619
+ const state = store2.getState();
3612
3620
  (_state$nodeCleanupFun = state.nodeCleanupFunctions.get(key)) === null || _state$nodeCleanupFun === void 0 ? void 0 : _state$nodeCleanupFun();
3613
3621
  state.nodeCleanupFunctions.delete(key);
3614
3622
  }
3615
- function getNodeLoadable(store, state, key) {
3616
- initializeNodeIfNewToStore(store, state, key, "get");
3617
- return getNode$1(key).get(store, state);
3623
+ function getNodeLoadable(store2, state, key) {
3624
+ initializeNodeIfNewToStore(store2, state, key, "get");
3625
+ return getNode$1(key).get(store2, state);
3618
3626
  }
3619
- function peekNodeLoadable(store, state, key) {
3620
- return getNode$1(key).peek(store, state);
3627
+ function peekNodeLoadable(store2, state, key) {
3628
+ return getNode$1(key).peek(store2, state);
3621
3629
  }
3622
3630
  function setUnvalidatedAtomValue_DEPRECATED(state, key, newValue) {
3623
3631
  var _node$invalidate;
@@ -3630,23 +3638,23 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3630
3638
  dirtyAtoms: setByAddingToSet$1(state.dirtyAtoms, key)
3631
3639
  };
3632
3640
  }
3633
- function setNodeValue(store, state, key, newValue) {
3641
+ function setNodeValue(store2, state, key, newValue) {
3634
3642
  const node = getNode$1(key);
3635
3643
  if (node.set == null) {
3636
3644
  throw new ReadOnlyRecoilValueError(`Attempt to set read-only RecoilValue: ${key}`);
3637
3645
  }
3638
3646
  const set2 = node.set;
3639
- initializeNodeIfNewToStore(store, state, key, "set");
3640
- return set2(store, state, newValue);
3647
+ initializeNodeIfNewToStore(store2, state, key, "set");
3648
+ return set2(store2, state, newValue);
3641
3649
  }
3642
- function peekNodeInfo(store, state, key) {
3643
- const storeState = store.getState();
3644
- const graph2 = store.getGraph(state.version);
3650
+ function peekNodeInfo(store2, state, key) {
3651
+ const storeState = store2.getState();
3652
+ const graph2 = store2.getGraph(state.version);
3645
3653
  const type = getNode$1(key).nodeType;
3646
3654
  return Recoil_lazyProxy$1({
3647
3655
  type
3648
3656
  }, {
3649
- loadable: () => peekNodeLoadable(store, state, key),
3657
+ loadable: () => peekNodeLoadable(store2, state, key),
3650
3658
  isActive: () => storeState.knownAtoms.has(key) || storeState.knownSelectors.has(key),
3651
3659
  isSet: () => type === "selector" ? false : state.atomValues.has(key),
3652
3660
  isModified: () => state.dirtyAtoms.has(key),
@@ -3657,7 +3665,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3657
3665
  subscribers: () => {
3658
3666
  var _storeState$nodeToCom, _storeState$nodeToCom2;
3659
3667
  return {
3660
- nodes: recoilValuesForKeys$1(Recoil_filterIterable(getDownstreamNodes(store, state, /* @__PURE__ */ new Set([key])), (nodeKey) => nodeKey !== key)),
3668
+ nodes: recoilValuesForKeys$1(Recoil_filterIterable(getDownstreamNodes(store2, state, /* @__PURE__ */ new Set([key])), (nodeKey) => nodeKey !== key)),
3661
3669
  components: Recoil_mapIterable((_storeState$nodeToCom = (_storeState$nodeToCom2 = storeState.nodeToComponentSubscriptions.get(key)) === null || _storeState$nodeToCom2 === void 0 ? void 0 : _storeState$nodeToCom2.values()) !== null && _storeState$nodeToCom !== void 0 ? _storeState$nodeToCom : [], ([name]) => ({
3662
3670
  name
3663
3671
  }))
@@ -3665,10 +3673,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3665
3673
  }
3666
3674
  });
3667
3675
  }
3668
- function getDownstreamNodes(store, state, keys2) {
3676
+ function getDownstreamNodes(store2, state, keys2) {
3669
3677
  const visitedNodes = /* @__PURE__ */ new Set();
3670
3678
  const visitingNodes = Array.from(keys2);
3671
- const graph2 = store.getGraph(state.version);
3679
+ const graph2 = store2.getGraph(state.version);
3672
3680
  for (let key = visitingNodes.pop(); key; key = visitingNodes.pop()) {
3673
3681
  var _graph$nodeToNodeSubs;
3674
3682
  visitedNodes.add(key);
@@ -3730,14 +3738,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3730
3738
  const {
3731
3739
  invalidateMemoizedSnapshot: invalidateMemoizedSnapshot$1
3732
3740
  } = Recoil_SnapshotCache;
3733
- function getRecoilValueAsLoadable(store, {
3741
+ function getRecoilValueAsLoadable(store2, {
3734
3742
  key
3735
- }, treeState = store.getState().currentTree) {
3743
+ }, treeState = store2.getState().currentTree) {
3736
3744
  var _storeState$nextTree, _storeState$previousT;
3737
- const storeState = store.getState();
3745
+ const storeState = store2.getState();
3738
3746
  if (!(treeState.version === storeState.currentTree.version || treeState.version === ((_storeState$nextTree = storeState.nextTree) === null || _storeState$nextTree === void 0 ? void 0 : _storeState$nextTree.version) || treeState.version === ((_storeState$previousT = storeState.previousTree) === null || _storeState$previousT === void 0 ? void 0 : _storeState$previousT.version)))
3739
3747
  ;
3740
- const loadable = getNodeLoadable$1(store, treeState, key);
3748
+ const loadable = getNodeLoadable$1(store2, treeState, key);
3741
3749
  if (loadable.state === "loading") {
3742
3750
  loadable.contents.catch(() => {
3743
3751
  return;
@@ -3756,11 +3764,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3756
3764
  });
3757
3765
  return result;
3758
3766
  }
3759
- function valueFromValueOrUpdater(store, state, {
3767
+ function valueFromValueOrUpdater(store2, state, {
3760
3768
  key
3761
3769
  }, valueOrUpdater) {
3762
3770
  if (typeof valueOrUpdater === "function") {
3763
- const current = getNodeLoadable$1(store, state, key);
3771
+ const current = getNodeLoadable$1(store2, state, key);
3764
3772
  if (current.state === "loading") {
3765
3773
  const msg = `Tried to set atom or selector "${key}" using an updater function while the current state is pending, this is not currently supported.`;
3766
3774
  throw Recoil_err$2(msg);
@@ -3772,14 +3780,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3772
3780
  return valueOrUpdater;
3773
3781
  }
3774
3782
  }
3775
- function applyAction(store, state, action) {
3783
+ function applyAction(store2, state, action) {
3776
3784
  if (action.type === "set") {
3777
3785
  const {
3778
3786
  recoilValue,
3779
3787
  valueOrUpdater
3780
3788
  } = action;
3781
- const newValue = valueFromValueOrUpdater(store, state, recoilValue, valueOrUpdater);
3782
- const writes = setNodeValue$1(store, state, recoilValue.key, newValue);
3789
+ const newValue = valueFromValueOrUpdater(store2, state, recoilValue, valueOrUpdater);
3790
+ const writes = setNodeValue$1(store2, state, recoilValue.key, newValue);
3783
3791
  for (const [key, loadable] of writes.entries()) {
3784
3792
  writeLoadableToTreeState(state, key, loadable);
3785
3793
  }
@@ -3824,27 +3832,27 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3824
3832
  state.dirtyAtoms.add(key);
3825
3833
  state.nonvalidatedAtoms.delete(key);
3826
3834
  }
3827
- function applyActionsToStore(store, actions) {
3828
- store.replaceState((state) => {
3835
+ function applyActionsToStore(store2, actions) {
3836
+ store2.replaceState((state) => {
3829
3837
  const newState = copyTreeState(state);
3830
3838
  for (const action of actions) {
3831
- applyAction(store, newState, action);
3839
+ applyAction(store2, newState, action);
3832
3840
  }
3833
- invalidateDownstreams(store, newState);
3841
+ invalidateDownstreams(store2, newState);
3834
3842
  invalidateMemoizedSnapshot$1();
3835
3843
  return newState;
3836
3844
  });
3837
3845
  }
3838
- function queueOrPerformStateUpdate(store, action) {
3846
+ function queueOrPerformStateUpdate(store2, action) {
3839
3847
  if (batchStack.length) {
3840
3848
  const actionsByStore = batchStack[batchStack.length - 1];
3841
- let actions = actionsByStore.get(store);
3849
+ let actions = actionsByStore.get(store2);
3842
3850
  if (!actions) {
3843
- actionsByStore.set(store, actions = []);
3851
+ actionsByStore.set(store2, actions = []);
3844
3852
  }
3845
3853
  actions.push(action);
3846
3854
  } else {
3847
- applyActionsToStore(store, [action]);
3855
+ applyActionsToStore(store2, [action]);
3848
3856
  }
3849
3857
  }
3850
3858
  const batchStack = [];
@@ -3852,8 +3860,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3852
3860
  const actionsByStore = /* @__PURE__ */ new Map();
3853
3861
  batchStack.push(actionsByStore);
3854
3862
  return () => {
3855
- for (const [store, actions] of actionsByStore) {
3856
- applyActionsToStore(store, actions);
3863
+ for (const [store2, actions] of actionsByStore) {
3864
+ applyActionsToStore(store2, actions);
3857
3865
  }
3858
3866
  batchStack.pop();
3859
3867
  };
@@ -3866,62 +3874,62 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3866
3874
  dirtyAtoms: new Set(state.dirtyAtoms)
3867
3875
  };
3868
3876
  }
3869
- function invalidateDownstreams(store, state) {
3870
- const downstreams = getDownstreamNodes$1(store, state, state.dirtyAtoms);
3877
+ function invalidateDownstreams(store2, state) {
3878
+ const downstreams = getDownstreamNodes$1(store2, state, state.dirtyAtoms);
3871
3879
  for (const key of downstreams) {
3872
3880
  var _getNodeMaybe, _getNodeMaybe$invalid;
3873
3881
  (_getNodeMaybe = getNodeMaybe$2(key)) === null || _getNodeMaybe === void 0 ? void 0 : (_getNodeMaybe$invalid = _getNodeMaybe.invalidate) === null || _getNodeMaybe$invalid === void 0 ? void 0 : _getNodeMaybe$invalid.call(_getNodeMaybe, state);
3874
3882
  }
3875
3883
  }
3876
- function setRecoilValue(store, recoilValue, valueOrUpdater) {
3877
- queueOrPerformStateUpdate(store, {
3884
+ function setRecoilValue(store2, recoilValue, valueOrUpdater) {
3885
+ queueOrPerformStateUpdate(store2, {
3878
3886
  type: "set",
3879
3887
  recoilValue,
3880
3888
  valueOrUpdater
3881
3889
  });
3882
3890
  }
3883
- function setRecoilValueLoadable(store, recoilValue, loadable) {
3891
+ function setRecoilValueLoadable(store2, recoilValue, loadable) {
3884
3892
  if (loadable instanceof DefaultValue$1$1) {
3885
- return setRecoilValue(store, recoilValue, loadable);
3893
+ return setRecoilValue(store2, recoilValue, loadable);
3886
3894
  }
3887
- queueOrPerformStateUpdate(store, {
3895
+ queueOrPerformStateUpdate(store2, {
3888
3896
  type: "setLoadable",
3889
3897
  recoilValue,
3890
3898
  loadable
3891
3899
  });
3892
3900
  }
3893
- function markRecoilValueModified(store, recoilValue) {
3894
- queueOrPerformStateUpdate(store, {
3901
+ function markRecoilValueModified(store2, recoilValue) {
3902
+ queueOrPerformStateUpdate(store2, {
3895
3903
  type: "markModified",
3896
3904
  recoilValue
3897
3905
  });
3898
3906
  }
3899
- function setUnvalidatedRecoilValue(store, recoilValue, unvalidatedValue) {
3900
- queueOrPerformStateUpdate(store, {
3907
+ function setUnvalidatedRecoilValue(store2, recoilValue, unvalidatedValue) {
3908
+ queueOrPerformStateUpdate(store2, {
3901
3909
  type: "setUnvalidated",
3902
3910
  recoilValue,
3903
3911
  unvalidatedValue
3904
3912
  });
3905
3913
  }
3906
- function subscribeToRecoilValue(store, {
3914
+ function subscribeToRecoilValue(store2, {
3907
3915
  key
3908
3916
  }, callback, componentDebugName = null) {
3909
3917
  const subID = getNextComponentID$1();
3910
- const storeState = store.getState();
3918
+ const storeState = store2.getState();
3911
3919
  if (!storeState.nodeToComponentSubscriptions.has(key)) {
3912
3920
  storeState.nodeToComponentSubscriptions.set(key, /* @__PURE__ */ new Map());
3913
3921
  }
3914
3922
  Recoil_nullthrows$1(storeState.nodeToComponentSubscriptions.get(key)).set(subID, [componentDebugName !== null && componentDebugName !== void 0 ? componentDebugName : "<not captured>", callback]);
3915
3923
  const mode = reactMode$1();
3916
3924
  if (mode.early && (mode.mode === "LEGACY" || mode.mode === "MUTABLE_SOURCE")) {
3917
- const nextTree = store.getState().nextTree;
3925
+ const nextTree = store2.getState().nextTree;
3918
3926
  if (nextTree && nextTree.dirtyAtoms.has(key)) {
3919
3927
  callback(nextTree);
3920
3928
  }
3921
3929
  }
3922
3930
  return {
3923
3931
  release: () => {
3924
- const releaseStoreState = store.getState();
3932
+ const releaseStoreState = store2.getState();
3925
3933
  const subs = releaseStoreState.nodeToComponentSubscriptions.get(key);
3926
3934
  if (subs === void 0 || !subs.has(subID)) {
3927
3935
  return;
@@ -3933,13 +3941,13 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3933
3941
  }
3934
3942
  };
3935
3943
  }
3936
- function refreshRecoilValue(store, recoilValue) {
3944
+ function refreshRecoilValue(store2, recoilValue) {
3937
3945
  var _node$clearCache;
3938
3946
  const {
3939
3947
  currentTree
3940
- } = store.getState();
3948
+ } = store2.getState();
3941
3949
  const node = getNode$2(recoilValue.key);
3942
- (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store, currentTree);
3950
+ (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store2, currentTree);
3943
3951
  }
3944
3952
  var Recoil_RecoilValueInterface = {
3945
3953
  RecoilValueReadOnly: RecoilValueReadOnly$1,
@@ -3984,8 +3992,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
3984
3992
  } = Recoil_RetentionZone;
3985
3993
  const SUSPENSE_TIMEOUT_MS = 12e4;
3986
3994
  const emptySet$1 = /* @__PURE__ */ new Set();
3987
- function releaseRetainablesNowOnCurrentTree(store, retainables) {
3988
- const storeState = store.getState();
3995
+ function releaseRetainablesNowOnCurrentTree(store2, retainables) {
3996
+ const storeState = store2.getState();
3989
3997
  const treeState = storeState.currentTree;
3990
3998
  if (storeState.nextTree) {
3991
3999
  return;
@@ -4000,15 +4008,15 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4000
4008
  nodes2.add(r2);
4001
4009
  }
4002
4010
  }
4003
- const releasableNodes = findReleasableNodes(store, nodes2);
4011
+ const releasableNodes = findReleasableNodes(store2, nodes2);
4004
4012
  for (const node of releasableNodes) {
4005
- releaseNode(store, treeState, node);
4013
+ releaseNode(store2, treeState, node);
4006
4014
  }
4007
4015
  }
4008
- function findReleasableNodes(store, searchFromNodes) {
4009
- const storeState = store.getState();
4016
+ function findReleasableNodes(store2, searchFromNodes) {
4017
+ const storeState = store2.getState();
4010
4018
  const treeState = storeState.currentTree;
4011
- const graph2 = store.getGraph(treeState.version);
4019
+ const graph2 = store2.getGraph(treeState.version);
4012
4020
  const releasableNodes = /* @__PURE__ */ new Set();
4013
4021
  const nonReleasableNodes = /* @__PURE__ */ new Set();
4014
4022
  findReleasableNodesInner(searchFromNodes);
@@ -4016,7 +4024,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4016
4024
  function findReleasableNodesInner(searchFromNodes2) {
4017
4025
  const releasableNodesFoundThisIteration = /* @__PURE__ */ new Set();
4018
4026
  const downstreams = getDownstreamNodesInTopologicalOrder(
4019
- store,
4027
+ store2,
4020
4028
  treeState,
4021
4029
  searchFromNodes2,
4022
4030
  releasableNodes,
@@ -4058,8 +4066,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4058
4066
  }
4059
4067
  }
4060
4068
  }
4061
- function getDownstreamNodesInTopologicalOrder(store, treeState, nodes2, doNotDescendInto1, doNotDescendInto2) {
4062
- const graph2 = store.getGraph(treeState.version);
4069
+ function getDownstreamNodesInTopologicalOrder(store2, treeState, nodes2, doNotDescendInto1, doNotDescendInto2) {
4070
+ const graph2 = store2.getGraph(treeState.version);
4063
4071
  const answer = [];
4064
4072
  const visited = /* @__PURE__ */ new Set();
4065
4073
  while (nodes2.size > 0) {
@@ -4085,12 +4093,12 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4085
4093
  answer.push(node);
4086
4094
  }
4087
4095
  }
4088
- function releaseNode(store, treeState, node) {
4096
+ function releaseNode(store2, treeState, node) {
4089
4097
  if (!Recoil_gkx("recoil_memory_managament_2020")) {
4090
4098
  return;
4091
4099
  }
4092
- cleanUpNode$1(store, node);
4093
- const storeState = store.getState();
4100
+ cleanUpNode$1(store2, node);
4101
+ const storeState = store2.getState();
4094
4102
  storeState.knownAtoms.delete(node);
4095
4103
  storeState.knownSelectors.delete(node);
4096
4104
  storeState.nodeTransactionSubscriptions.delete(node);
@@ -4131,41 +4139,41 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4131
4139
  return retainedBy;
4132
4140
  }
4133
4141
  }
4134
- function scheduleOrPerformPossibleReleaseOfRetainable(store, retainable) {
4135
- const state = store.getState();
4142
+ function scheduleOrPerformPossibleReleaseOfRetainable(store2, retainable) {
4143
+ const state = store2.getState();
4136
4144
  if (state.nextTree) {
4137
4145
  state.retention.retainablesToCheckForRelease.add(retainable);
4138
4146
  } else {
4139
- releaseRetainablesNowOnCurrentTree(store, /* @__PURE__ */ new Set([retainable]));
4147
+ releaseRetainablesNowOnCurrentTree(store2, /* @__PURE__ */ new Set([retainable]));
4140
4148
  }
4141
4149
  }
4142
- function updateRetainCount(store, retainable, delta) {
4150
+ function updateRetainCount(store2, retainable, delta) {
4143
4151
  var _map$get;
4144
4152
  if (!Recoil_gkx("recoil_memory_managament_2020")) {
4145
4153
  return;
4146
4154
  }
4147
- const map2 = store.getState().retention.referenceCounts;
4155
+ const map2 = store2.getState().retention.referenceCounts;
4148
4156
  const newCount = ((_map$get = map2.get(retainable)) !== null && _map$get !== void 0 ? _map$get : 0) + delta;
4149
4157
  if (newCount === 0) {
4150
- updateRetainCountToZero(store, retainable);
4158
+ updateRetainCountToZero(store2, retainable);
4151
4159
  } else {
4152
4160
  map2.set(retainable, newCount);
4153
4161
  }
4154
4162
  }
4155
- function updateRetainCountToZero(store, retainable) {
4163
+ function updateRetainCountToZero(store2, retainable) {
4156
4164
  if (!Recoil_gkx("recoil_memory_managament_2020")) {
4157
4165
  return;
4158
4166
  }
4159
- const map2 = store.getState().retention.referenceCounts;
4167
+ const map2 = store2.getState().retention.referenceCounts;
4160
4168
  map2.delete(retainable);
4161
- scheduleOrPerformPossibleReleaseOfRetainable(store, retainable);
4169
+ scheduleOrPerformPossibleReleaseOfRetainable(store2, retainable);
4162
4170
  }
4163
- function releaseScheduledRetainablesNow(store) {
4171
+ function releaseScheduledRetainablesNow(store2) {
4164
4172
  if (!Recoil_gkx("recoil_memory_managament_2020")) {
4165
4173
  return;
4166
4174
  }
4167
- const state = store.getState();
4168
- releaseRetainablesNowOnCurrentTree(store, state.retention.retainablesToCheckForRelease);
4175
+ const state = store2.getState();
4176
+ releaseRetainablesNowOnCurrentTree(store2, state.retention.retainablesToCheckForRelease);
4169
4177
  state.retention.retainablesToCheckForRelease.clear();
4170
4178
  }
4171
4179
  function retainedByOptionWithDefault(r2) {
@@ -4375,13 +4383,13 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4375
4383
  replaceState: (replacer) => {
4376
4384
  storeState.currentTree = replacer(storeState.currentTree);
4377
4385
  },
4378
- getGraph: (version2) => {
4386
+ getGraph: (version) => {
4379
4387
  const graphs = storeState.graphsByVersion;
4380
- if (graphs.has(version2)) {
4381
- return Recoil_nullthrows$1(graphs.get(version2));
4388
+ if (graphs.has(version)) {
4389
+ return Recoil_nullthrows$1(graphs.get(version));
4382
4390
  }
4383
4391
  const newGraph = graph$1();
4384
- graphs.set(version2, newGraph);
4392
+ graphs.set(version, newGraph);
4385
4393
  return newGraph;
4386
4394
  },
4387
4395
  subscribeToTransactions: () => ({
@@ -4446,13 +4454,13 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4446
4454
  return this._store.storeID;
4447
4455
  }
4448
4456
  }
4449
- function cloneStoreState(store, treeState, bumpVersion = false) {
4450
- const storeState = store.getState();
4451
- const version2 = bumpVersion ? getNextTreeStateVersion$2() : treeState.version;
4457
+ function cloneStoreState(store2, treeState, bumpVersion = false) {
4458
+ const storeState = store2.getState();
4459
+ const version = bumpVersion ? getNextTreeStateVersion$2() : treeState.version;
4452
4460
  return {
4453
4461
  currentTree: {
4454
- version: bumpVersion ? version2 : treeState.version,
4455
- stateID: bumpVersion ? version2 : treeState.stateID,
4462
+ version: bumpVersion ? version : treeState.version,
4463
+ stateID: bumpVersion ? version : treeState.stateID,
4456
4464
  transactionMetadata: {
4457
4465
  ...treeState.transactionMetadata
4458
4466
  },
@@ -4470,7 +4478,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4470
4478
  nodeToComponentSubscriptions: /* @__PURE__ */ new Map(),
4471
4479
  queuedComponentCallbacks_DEPRECATED: [],
4472
4480
  suspendedComponentResolvers: /* @__PURE__ */ new Set(),
4473
- graphsByVersion: (/* @__PURE__ */ new Map()).set(version2, store.getGraph(treeState.version)),
4481
+ graphsByVersion: (/* @__PURE__ */ new Map()).set(version, store2.getGraph(treeState.version)),
4474
4482
  retention: {
4475
4483
  referenceCounts: /* @__PURE__ */ new Map(),
4476
4484
  nodesRetainedByZone: /* @__PURE__ */ new Map(),
@@ -4485,23 +4493,23 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4485
4493
  return initializeState != null ? snapshot.map(initializeState) : snapshot;
4486
4494
  }
4487
4495
  const [memoizedCloneSnapshot, invalidateMemoizedSnapshot$2] = memoizeOneWithArgsHashAndInvalidation$1(
4488
- (store, version2) => {
4496
+ (store2, version) => {
4489
4497
  var _storeState$nextTree;
4490
- const storeState = store.getState();
4491
- const treeState = version2 === "latest" ? (_storeState$nextTree = storeState.nextTree) !== null && _storeState$nextTree !== void 0 ? _storeState$nextTree : storeState.currentTree : Recoil_nullthrows$1(storeState.previousTree);
4492
- return new Snapshot(cloneStoreState(store, treeState), store.storeID);
4498
+ const storeState = store2.getState();
4499
+ const treeState = version === "latest" ? (_storeState$nextTree = storeState.nextTree) !== null && _storeState$nextTree !== void 0 ? _storeState$nextTree : storeState.currentTree : Recoil_nullthrows$1(storeState.previousTree);
4500
+ return new Snapshot(cloneStoreState(store2, treeState), store2.storeID);
4493
4501
  },
4494
- (store, version2) => {
4502
+ (store2, version) => {
4495
4503
  var _store$getState$nextT, _store$getState$previ;
4496
- return String(version2) + String(store.storeID) + String((_store$getState$nextT = store.getState().nextTree) === null || _store$getState$nextT === void 0 ? void 0 : _store$getState$nextT.version) + String(store.getState().currentTree.version) + String((_store$getState$previ = store.getState().previousTree) === null || _store$getState$previ === void 0 ? void 0 : _store$getState$previ.version);
4504
+ return String(version) + String(store2.storeID) + String((_store$getState$nextT = store2.getState().nextTree) === null || _store$getState$nextT === void 0 ? void 0 : _store$getState$nextT.version) + String(store2.getState().currentTree.version) + String((_store$getState$previ = store2.getState().previousTree) === null || _store$getState$previ === void 0 ? void 0 : _store$getState$previ.version);
4497
4505
  }
4498
4506
  );
4499
4507
  setInvalidateMemoizedSnapshot$1(invalidateMemoizedSnapshot$2);
4500
- function cloneSnapshot(store, version2 = "latest") {
4501
- const snapshot = memoizedCloneSnapshot(store, version2);
4508
+ function cloneSnapshot(store2, version = "latest") {
4509
+ const snapshot = memoizedCloneSnapshot(store2, version);
4502
4510
  if (!snapshot.isRetained()) {
4503
4511
  invalidateMemoizedSnapshot$2();
4504
- return memoizedCloneSnapshot(store, version2);
4512
+ return memoizedCloneSnapshot(store2, version);
4505
4513
  }
4506
4514
  return snapshot;
4507
4515
  }
@@ -4511,27 +4519,27 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4511
4519
  _defineProperty$a(this, "_batch", void 0);
4512
4520
  _defineProperty$a(this, "set", (recoilState, newValueOrUpdater) => {
4513
4521
  this.checkRefCount_INTERNAL();
4514
- const store = this.getStore_INTERNAL();
4522
+ const store2 = this.getStore_INTERNAL();
4515
4523
  this._batch(() => {
4516
- updateRetainCount$1(store, recoilState.key, 1);
4524
+ updateRetainCount$1(store2, recoilState.key, 1);
4517
4525
  setRecoilValue$1(this.getStore_INTERNAL(), recoilState, newValueOrUpdater);
4518
4526
  });
4519
4527
  });
4520
4528
  _defineProperty$a(this, "reset", (recoilState) => {
4521
4529
  this.checkRefCount_INTERNAL();
4522
- const store = this.getStore_INTERNAL();
4530
+ const store2 = this.getStore_INTERNAL();
4523
4531
  this._batch(() => {
4524
- updateRetainCount$1(store, recoilState.key, 1);
4532
+ updateRetainCount$1(store2, recoilState.key, 1);
4525
4533
  setRecoilValue$1(this.getStore_INTERNAL(), recoilState, DEFAULT_VALUE$1$1);
4526
4534
  });
4527
4535
  });
4528
4536
  _defineProperty$a(this, "setUnvalidatedAtomValues_DEPRECATED", (values) => {
4529
4537
  this.checkRefCount_INTERNAL();
4530
- const store = this.getStore_INTERNAL();
4538
+ const store2 = this.getStore_INTERNAL();
4531
4539
  batchUpdates$1(() => {
4532
4540
  for (const [k2, v2] of values.entries()) {
4533
- updateRetainCount$1(store, k2, 1);
4534
- setUnvalidatedRecoilValue$1(store, new AbstractRecoilValue$2(k2), v2);
4541
+ updateRetainCount$1(store2, k2, 1);
4542
+ setUnvalidatedRecoilValue$1(store2, new AbstractRecoilValue$2(k2), v2);
4535
4543
  }
4536
4544
  });
4537
4545
  });
@@ -4629,18 +4637,18 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4629
4637
  addTransactionMetadata: notInAContext
4630
4638
  });
4631
4639
  let stateReplacerIsBeingExecuted = false;
4632
- function startNextTreeIfNeeded(store) {
4640
+ function startNextTreeIfNeeded(store2) {
4633
4641
  if (stateReplacerIsBeingExecuted) {
4634
4642
  throw Recoil_err$2("An atom update was triggered within the execution of a state updater function. State updater functions provided to Recoil must be pure functions.");
4635
4643
  }
4636
- const storeState = store.getState();
4644
+ const storeState = store2.getState();
4637
4645
  if (storeState.nextTree === null) {
4638
4646
  if (Recoil_gkx("recoil_memory_managament_2020") && Recoil_gkx("recoil_release_on_cascading_update_killswitch_2021")) {
4639
4647
  if (storeState.commitDepth > 0) {
4640
- releaseScheduledRetainablesNow$1(store);
4648
+ releaseScheduledRetainablesNow$1(store2);
4641
4649
  }
4642
4650
  }
4643
- const version2 = storeState.currentTree.version;
4651
+ const version = storeState.currentTree.version;
4644
4652
  const nextVersion = getNextTreeStateVersion$3();
4645
4653
  storeState.nextTree = {
4646
4654
  ...storeState.currentTree,
@@ -4649,7 +4657,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4649
4657
  dirtyAtoms: /* @__PURE__ */ new Set(),
4650
4658
  transactionMetadata: {}
4651
4659
  };
4652
- storeState.graphsByVersion.set(nextVersion, cloneGraph$1(Recoil_nullthrows$1(storeState.graphsByVersion.get(version2))));
4660
+ storeState.graphsByVersion.set(nextVersion, cloneGraph$1(Recoil_nullthrows$1(storeState.graphsByVersion.get(version))));
4653
4661
  }
4654
4662
  }
4655
4663
  const AppContext = React__default.default.createContext({
@@ -4661,8 +4669,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4661
4669
  const mutableSource = useContext(MutableSourceContext);
4662
4670
  return mutableSource;
4663
4671
  }
4664
- function notifyComponents(store, storeState, treeState) {
4665
- const dependentNodes = getDownstreamNodes$2(store, treeState, treeState.dirtyAtoms);
4672
+ function notifyComponents(store2, storeState, treeState) {
4673
+ const dependentNodes = getDownstreamNodes$2(store2, treeState, treeState.dirtyAtoms);
4666
4674
  for (const key of dependentNodes) {
4667
4675
  const comps = storeState.nodeToComponentSubscriptions.get(key);
4668
4676
  if (comps) {
@@ -4672,23 +4680,23 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4672
4680
  }
4673
4681
  }
4674
4682
  }
4675
- function sendEndOfBatchNotifications(store) {
4676
- const storeState = store.getState();
4683
+ function sendEndOfBatchNotifications(store2) {
4684
+ const storeState = store2.getState();
4677
4685
  const treeState = storeState.currentTree;
4678
4686
  const dirtyAtoms = treeState.dirtyAtoms;
4679
4687
  if (dirtyAtoms.size) {
4680
4688
  for (const [key, subscriptions] of storeState.nodeTransactionSubscriptions) {
4681
4689
  if (dirtyAtoms.has(key)) {
4682
4690
  for (const [_, subscription] of subscriptions) {
4683
- subscription(store);
4691
+ subscription(store2);
4684
4692
  }
4685
4693
  }
4686
4694
  }
4687
4695
  for (const [_, subscription] of storeState.transactionSubscriptions) {
4688
- subscription(store);
4696
+ subscription(store2);
4689
4697
  }
4690
4698
  if (!reactMode$2().early || storeState.suspendedComponentResolvers.size > 0) {
4691
- notifyComponents(store, storeState, treeState);
4699
+ notifyComponents(store2, storeState, treeState);
4692
4700
  storeState.suspendedComponentResolvers.forEach((cb) => cb());
4693
4701
  storeState.suspendedComponentResolvers.clear();
4694
4702
  }
@@ -4696,8 +4704,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4696
4704
  storeState.queuedComponentCallbacks_DEPRECATED.forEach((cb) => cb(treeState));
4697
4705
  storeState.queuedComponentCallbacks_DEPRECATED.splice(0, storeState.queuedComponentCallbacks_DEPRECATED.length);
4698
4706
  }
4699
- function endBatch(store) {
4700
- const storeState = store.getState();
4707
+ function endBatch(store2) {
4708
+ const storeState = store2.getState();
4701
4709
  storeState.commitDepth++;
4702
4710
  try {
4703
4711
  const {
@@ -4709,7 +4717,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4709
4717
  storeState.previousTree = storeState.currentTree;
4710
4718
  storeState.currentTree = nextTree;
4711
4719
  storeState.nextTree = null;
4712
- sendEndOfBatchNotifications(store);
4720
+ sendEndOfBatchNotifications(store2);
4713
4721
  if (storeState.previousTree != null) {
4714
4722
  storeState.graphsByVersion.delete(storeState.previousTree.version);
4715
4723
  } else {
@@ -4718,7 +4726,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4718
4726
  storeState.previousTree = null;
4719
4727
  if (Recoil_gkx("recoil_memory_managament_2020")) {
4720
4728
  if (nextTree == null) {
4721
- releaseScheduledRetainablesNow$1(store);
4729
+ releaseScheduledRetainablesNow$1(store2);
4722
4730
  }
4723
4731
  }
4724
4732
  } finally {
@@ -4745,12 +4753,12 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4745
4753
  });
4746
4754
  return null;
4747
4755
  }
4748
- function initialStoreState_DEPRECATED(store, initializeState) {
4756
+ function initialStoreState_DEPRECATED(store2, initializeState) {
4749
4757
  const initial2 = makeEmptyStoreState$2();
4750
4758
  initializeState({
4751
4759
  set: (atom2, value) => {
4752
4760
  const state = initial2.currentTree;
4753
- const writes = setNodeValue$2(store, state, atom2.key, value);
4761
+ const writes = setNodeValue$2(store2, state, atom2.key, value);
4754
4762
  const writtenNodes = new Set(writes.keys());
4755
4763
  const nonvalidatedAtoms = state.nonvalidatedAtoms.clone();
4756
4764
  for (const n2 of writtenNodes) {
@@ -4787,13 +4795,13 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4787
4795
  children
4788
4796
  }) {
4789
4797
  let storeStateRef;
4790
- const getGraph = (version2) => {
4798
+ const getGraph = (version) => {
4791
4799
  const graphs = storeStateRef.current.graphsByVersion;
4792
- if (graphs.has(version2)) {
4793
- return Recoil_nullthrows$1(graphs.get(version2));
4800
+ if (graphs.has(version)) {
4801
+ return Recoil_nullthrows$1(graphs.get(version));
4794
4802
  }
4795
4803
  const newGraph = graph$2();
4796
- graphs.set(version2, newGraph);
4804
+ graphs.set(version, newGraph);
4797
4805
  return newGraph;
4798
4806
  };
4799
4807
  const subscribeToTransactions = (callback, key) => {
@@ -4873,13 +4881,13 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4873
4881
  storeStateRef = Recoil_useRefInitOnce(() => initializeState_DEPRECATED != null ? initialStoreState_DEPRECATED(storeRef.current, initializeState_DEPRECATED) : initializeState != null ? initialStoreState(initializeState) : makeEmptyStoreState$2());
4874
4882
  const mutableSource = useMemo$2(() => createMutableSource$1 === null || createMutableSource$1 === void 0 ? void 0 : createMutableSource$1(storeStateRef, () => storeStateRef.current.currentTree.version), [storeStateRef]);
4875
4883
  useEffect$4(() => {
4876
- const store = storeRef.current;
4877
- for (const atomKey of new Set(store.getState().knownAtoms)) {
4878
- initializeNode$2(store, atomKey, "get");
4884
+ const store2 = storeRef.current;
4885
+ for (const atomKey of new Set(store2.getState().knownAtoms)) {
4886
+ initializeNode$2(store2, atomKey, "get");
4879
4887
  }
4880
4888
  return () => {
4881
- for (const atomKey of store.getState().knownAtoms) {
4882
- cleanUpNode$2(store, atomKey);
4889
+ for (const atomKey of store2.getState().knownAtoms) {
4890
+ cleanUpNode$2(store2, atomKey);
4883
4891
  }
4884
4892
  };
4885
4893
  }, [storeRef]);
@@ -4973,31 +4981,31 @@ var __privateWrapper = (obj, member, setter, getter) => ({
4973
4981
  if (!Recoil_gkx("recoil_memory_managament_2020")) {
4974
4982
  return;
4975
4983
  }
4976
- const store = storeRef.current;
4984
+ const store2 = storeRef.current;
4977
4985
  if (timeoutID.current && !isSSR$2) {
4978
4986
  window.clearTimeout(timeoutID.current);
4979
4987
  timeoutID.current = null;
4980
4988
  } else {
4981
4989
  for (const r2 of retainables) {
4982
- updateRetainCount$2(store, r2, 1);
4990
+ updateRetainCount$2(store2, r2, 1);
4983
4991
  }
4984
4992
  }
4985
4993
  return () => {
4986
4994
  for (const r2 of retainables) {
4987
- updateRetainCount$2(store, r2, -1);
4995
+ updateRetainCount$2(store2, r2, -1);
4988
4996
  }
4989
4997
  };
4990
4998
  }, [storeRef, ...retainables]);
4991
4999
  const timeoutID = useRef$3$1();
4992
5000
  const previousRetainables = Recoil_usePrevious$1(retainables);
4993
5001
  if (!isSSR$2 && (previousRetainables === void 0 || !Recoil_shallowArrayEqual(previousRetainables, retainables))) {
4994
- const store = storeRef.current;
5002
+ const store2 = storeRef.current;
4995
5003
  for (const r2 of retainables) {
4996
- updateRetainCount$2(store, r2, 1);
5004
+ updateRetainCount$2(store2, r2, 1);
4997
5005
  }
4998
5006
  if (previousRetainables) {
4999
5007
  for (const r2 of previousRetainables) {
5000
- updateRetainCount$2(store, r2, -1);
5008
+ updateRetainCount$2(store2, r2, -1);
5001
5009
  }
5002
5010
  }
5003
5011
  if (timeoutID.current) {
@@ -5006,7 +5014,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5006
5014
  timeoutID.current = window.setTimeout(() => {
5007
5015
  timeoutID.current = null;
5008
5016
  for (const r2 of retainables) {
5009
- updateRetainCount$2(store, r2, -1);
5017
+ updateRetainCount$2(store2, r2, -1);
5010
5018
  }
5011
5019
  }, SUSPENSE_TIMEOUT_MS$1);
5012
5020
  }
@@ -5087,26 +5095,26 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5087
5095
  subscriptions.current.delete(key);
5088
5096
  }
5089
5097
  }, [subscriptions]);
5090
- const updateState = useCallback$1$1((_state, key) => {
5098
+ const updateState = useCallback$1$1((_state2, key) => {
5091
5099
  if (subscriptions.current.has(key)) {
5092
5100
  forceUpdate([]);
5093
5101
  }
5094
5102
  }, []);
5095
5103
  useEffect$3$1(() => {
5096
- const store = storeRef.current;
5104
+ const store2 = storeRef.current;
5097
5105
  Recoil_differenceSets(recoilValuesUsed.current, previousSubscriptions.current).forEach((key) => {
5098
5106
  if (subscriptions.current.has(key)) {
5099
5107
  return;
5100
5108
  }
5101
- const sub = subscribeToRecoilValue$1(store, new AbstractRecoilValue$3(key), (state2) => updateState(state2, key), componentName);
5109
+ const sub = subscribeToRecoilValue$1(store2, new AbstractRecoilValue$3(key), (state2) => updateState(state2, key), componentName);
5102
5110
  subscriptions.current.set(key, sub);
5103
- const state = store.getState();
5111
+ const state = store2.getState();
5104
5112
  if (state.nextTree) {
5105
- store.getState().queuedComponentCallbacks_DEPRECATED.push(() => {
5106
- updateState(store.getState(), key);
5113
+ store2.getState().queuedComponentCallbacks_DEPRECATED.push(() => {
5114
+ updateState(store2.getState(), key);
5107
5115
  });
5108
5116
  } else {
5109
- updateState(store.getState(), key);
5117
+ updateState(store2.getState(), key);
5110
5118
  }
5111
5119
  });
5112
5120
  Recoil_differenceSets(previousSubscriptions.current, recoilValuesUsed.current).forEach((key) => {
@@ -5167,10 +5175,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5167
5175
  const componentName = Recoil_useComponentName();
5168
5176
  const getSnapshot = useCallback$1$1(() => {
5169
5177
  var _storeState$nextTree2;
5170
- const store = storeRef.current;
5171
- const storeState = store.getState();
5178
+ const store2 = storeRef.current;
5179
+ const storeState = store2.getState();
5172
5180
  const treeState = reactMode$3().early ? (_storeState$nextTree2 = storeState.nextTree) !== null && _storeState$nextTree2 !== void 0 ? _storeState$nextTree2 : storeState.currentTree : storeState.currentTree;
5173
- const loadable = getRecoilValueAsLoadable$2(store, recoilValue, treeState);
5181
+ const loadable = getRecoilValueAsLoadable$2(store2, recoilValue, treeState);
5174
5182
  return {
5175
5183
  loadable,
5176
5184
  key: recoilValue.key
@@ -5190,8 +5198,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5190
5198
  }, []);
5191
5199
  const getMemoizedSnapshot = useMemo$1$1(() => memoizePreviousSnapshot(getSnapshot), [getSnapshot, memoizePreviousSnapshot]);
5192
5200
  const subscribe = useCallback$1$1((notify) => {
5193
- const store = storeRef.current;
5194
- const subscription = subscribeToRecoilValue$1(store, recoilValue, notify, componentName);
5201
+ const store2 = storeRef.current;
5202
+ const subscription = subscribeToRecoilValue$1(store2, recoilValue, notify, componentName);
5195
5203
  return subscription.release;
5196
5204
  }, [storeRef, recoilValue, componentName]);
5197
5205
  return useSyncExternalStore$1(
@@ -5204,18 +5212,18 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5204
5212
  const storeRef = useStoreRef$2();
5205
5213
  const getLoadable = useCallback$1$1(() => {
5206
5214
  var _storeState$nextTree3;
5207
- const store = storeRef.current;
5208
- const storeState = store.getState();
5215
+ const store2 = storeRef.current;
5216
+ const storeState = store2.getState();
5209
5217
  const treeState = reactMode$3().early ? (_storeState$nextTree3 = storeState.nextTree) !== null && _storeState$nextTree3 !== void 0 ? _storeState$nextTree3 : storeState.currentTree : storeState.currentTree;
5210
- return getRecoilValueAsLoadable$2(store, recoilValue, treeState);
5218
+ return getRecoilValueAsLoadable$2(store2, recoilValue, treeState);
5211
5219
  }, [storeRef, recoilValue]);
5212
5220
  const getLoadableWithTesting = useCallback$1$1(() => {
5213
5221
  return getLoadable();
5214
5222
  }, [getLoadable]);
5215
5223
  const componentName = Recoil_useComponentName();
5216
5224
  const subscribe = useCallback$1$1((_storeState, notify) => {
5217
- const store = storeRef.current;
5218
- const subscription = subscribeToRecoilValue$1(store, recoilValue, () => {
5225
+ const store2 = storeRef.current;
5226
+ const subscription = subscribeToRecoilValue$1(store2, recoilValue, () => {
5219
5227
  if (!Recoil_gkx("recoil_suppress_rerender_in_callback")) {
5220
5228
  return notify();
5221
5229
  }
@@ -5243,10 +5251,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5243
5251
  const componentName = Recoil_useComponentName();
5244
5252
  const getLoadable = useCallback$1$1(() => {
5245
5253
  var _storeState$nextTree4;
5246
- const store = storeRef.current;
5247
- const storeState = store.getState();
5254
+ const store2 = storeRef.current;
5255
+ const storeState = store2.getState();
5248
5256
  const treeState = reactMode$3().early ? (_storeState$nextTree4 = storeState.nextTree) !== null && _storeState$nextTree4 !== void 0 ? _storeState$nextTree4 : storeState.currentTree : storeState.currentTree;
5249
- return getRecoilValueAsLoadable$2(store, recoilValue, treeState);
5257
+ return getRecoilValueAsLoadable$2(store2, recoilValue, treeState);
5250
5258
  }, [storeRef, recoilValue]);
5251
5259
  const getState2 = useCallback$1$1(() => ({
5252
5260
  loadable: getLoadable(),
@@ -5257,7 +5265,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5257
5265
  return prevState.loadable.is(nextState.loadable) && prevState.key === nextState.key ? prevState : nextState;
5258
5266
  }, [getState2]);
5259
5267
  useEffect$3$1(() => {
5260
- const subscription = subscribeToRecoilValue$1(storeRef.current, recoilValue, (_state) => {
5268
+ const subscription = subscribeToRecoilValue$1(storeRef.current, recoilValue, (_state2) => {
5261
5269
  setState(updateState);
5262
5270
  }, componentName);
5263
5271
  setState(updateState);
@@ -5272,10 +5280,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5272
5280
  const componentName = Recoil_useComponentName();
5273
5281
  const getLoadable = useCallback$1$1(() => {
5274
5282
  var _storeState$nextTree5;
5275
- const store = storeRef.current;
5276
- const storeState = store.getState();
5283
+ const store2 = storeRef.current;
5284
+ const storeState = store2.getState();
5277
5285
  const treeState = reactMode$3().early ? (_storeState$nextTree5 = storeState.nextTree) !== null && _storeState$nextTree5 !== void 0 ? _storeState$nextTree5 : storeState.currentTree : storeState.currentTree;
5278
- return getRecoilValueAsLoadable$2(store, recoilValue, treeState);
5286
+ return getRecoilValueAsLoadable$2(store2, recoilValue, treeState);
5279
5287
  }, [storeRef, recoilValue]);
5280
5288
  const loadable = getLoadable();
5281
5289
  const prevLoadableRef = useRef$4(loadable);
@@ -5283,9 +5291,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5283
5291
  prevLoadableRef.current = loadable;
5284
5292
  });
5285
5293
  useEffect$3$1(() => {
5286
- const store = storeRef.current;
5287
- const storeState = store.getState();
5288
- const subscription = subscribeToRecoilValue$1(store, recoilValue, (_state) => {
5294
+ const store2 = storeRef.current;
5295
+ const storeState = store2.getState();
5296
+ const subscription = subscribeToRecoilValue$1(store2, recoilValue, (_state2) => {
5289
5297
  var _prevLoadableRef$curr;
5290
5298
  if (!Recoil_gkx("recoil_suppress_rerender_in_callback")) {
5291
5299
  return forceUpdate([]);
@@ -5297,7 +5305,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5297
5305
  prevLoadableRef.current = newLoadable;
5298
5306
  }, componentName);
5299
5307
  if (storeState.nextTree) {
5300
- store.getState().queuedComponentCallbacks_DEPRECATED.push(() => {
5308
+ store2.getState().queuedComponentCallbacks_DEPRECATED.push(() => {
5301
5309
  prevLoadableRef.current = null;
5302
5310
  forceUpdate([]);
5303
5311
  });
@@ -5466,11 +5474,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5466
5474
  return Recoil_mergeMaps(state.nonvalidatedAtoms.toMap(), persistedAtomContentsValues);
5467
5475
  }
5468
5476
  function useTransactionObservation_DEPRECATED(callback) {
5469
- useTransactionSubscription(useCallback$2$1((store) => {
5470
- let previousTree = store.getState().previousTree;
5471
- const currentTree = store.getState().currentTree;
5477
+ useTransactionSubscription(useCallback$2$1((store2) => {
5478
+ let previousTree = store2.getState().previousTree;
5479
+ const currentTree = store2.getState().currentTree;
5472
5480
  if (!previousTree) {
5473
- previousTree = store.getState().currentTree;
5481
+ previousTree = store2.getState().currentTree;
5474
5482
  }
5475
5483
  const atomValues = externallyVisibleAtomValuesInState(currentTree);
5476
5484
  const previousAtomValues = externallyVisibleAtomValuesInState(previousTree);
@@ -5496,9 +5504,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5496
5504
  }, [callback]));
5497
5505
  }
5498
5506
  function useRecoilTransactionObserver(callback) {
5499
- useTransactionSubscription(useCallback$2$1((store) => {
5500
- const snapshot = cloneSnapshot$1(store, "latest");
5501
- const previousSnapshot = cloneSnapshot$1(store, "previous");
5507
+ useTransactionSubscription(useCallback$2$1((store2) => {
5508
+ const snapshot = cloneSnapshot$1(store2, "latest");
5509
+ const previousSnapshot = cloneSnapshot$1(store2, "previous");
5502
5510
  callback({
5503
5511
  snapshot,
5504
5512
  previousSnapshot
@@ -5511,7 +5519,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5511
5519
  const previousSnapshot = Recoil_usePrevious$1(snapshot);
5512
5520
  const timeoutID = useRef$5();
5513
5521
  const releaseRef = useRef$5();
5514
- useTransactionSubscription(useCallback$2$1((store) => setSnapshot(cloneSnapshot$1(store)), []));
5522
+ useTransactionSubscription(useCallback$2$1((store2) => setSnapshot(cloneSnapshot$1(store2)), []));
5515
5523
  useEffect$4$1(() => {
5516
5524
  const release = snapshot.retain();
5517
5525
  if (timeoutID.current && !isSSR$4) {
@@ -5543,9 +5551,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5543
5551
  }
5544
5552
  return snapshot;
5545
5553
  }
5546
- function gotoSnapshot(store, snapshot) {
5554
+ function gotoSnapshot(store2, snapshot) {
5547
5555
  var _storeState$nextTree;
5548
- const storeState = store.getState();
5556
+ const storeState = store2.getState();
5549
5557
  const prev = (_storeState$nextTree = storeState.nextTree) !== null && _storeState$nextTree !== void 0 ? _storeState$nextTree : storeState.currentTree;
5550
5558
  const next = snapshot.getStore_INTERNAL().getState().currentTree;
5551
5559
  batchUpdates$3(() => {
@@ -5559,9 +5567,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5559
5567
  }
5560
5568
  }
5561
5569
  keysToUpdate.forEach((key) => {
5562
- setRecoilValueLoadable$1(store, new AbstractRecoilValue$4(key), next.atomValues.has(key) ? Recoil_nullthrows$1(next.atomValues.get(key)) : DEFAULT_VALUE$3);
5570
+ setRecoilValueLoadable$1(store2, new AbstractRecoilValue$4(key), next.atomValues.has(key) ? Recoil_nullthrows$1(next.atomValues.get(key)) : DEFAULT_VALUE$3);
5563
5571
  });
5564
- store.replaceState((state) => ({
5572
+ store2.replaceState((state) => ({
5565
5573
  ...state,
5566
5574
  stateID: snapshot.getID()
5567
5575
  }));
@@ -5606,17 +5614,17 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5606
5614
  if (reactMode$4().mode === "MUTABLE_SOURCE") {
5607
5615
  console.warn("Warning: There are known issues using useRecoilBridgeAcrossReactRoots() in recoil_mutable_source rendering mode. Please consider upgrading to recoil_sync_external_store mode.");
5608
5616
  }
5609
- const store = useStoreRef$5().current;
5617
+ const store2 = useStoreRef$5().current;
5610
5618
  return useMemo$2$1(() => {
5611
5619
  function RecoilBridge({
5612
5620
  children
5613
5621
  }) {
5614
5622
  return /* @__PURE__ */ React__default.default.createElement(RecoilRoot$1, {
5615
- store_INTERNAL: store
5623
+ store_INTERNAL: store2
5616
5624
  }, children);
5617
5625
  }
5618
5626
  return RecoilBridge;
5619
- }, [store]);
5627
+ }, [store2]);
5620
5628
  }
5621
5629
  var Recoil_useRecoilBridgeAcrossReactRoots = useRecoilBridgeAcrossReactRoots;
5622
5630
  const {
@@ -5639,7 +5647,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5639
5647
  return getNode$5(recoilValue.key).nodeType === "atom";
5640
5648
  }
5641
5649
  class TransactionInterfaceImpl {
5642
- constructor(store, treeState) {
5650
+ constructor(store2, treeState) {
5643
5651
  _defineProperty$a(this, "_store", void 0);
5644
5652
  _defineProperty$a(this, "_treeState", void 0);
5645
5653
  _defineProperty$a(this, "_changes", void 0);
@@ -5674,7 +5682,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5674
5682
  _defineProperty$a(this, "reset", (recoilState) => {
5675
5683
  this.set(recoilState, DEFAULT_VALUE$4);
5676
5684
  });
5677
- this._store = store;
5685
+ this._store = store2;
5678
5686
  this._treeState = treeState;
5679
5687
  this._changes = /* @__PURE__ */ new Map();
5680
5688
  }
@@ -5690,10 +5698,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5690
5698
  return newState;
5691
5699
  }
5692
5700
  }
5693
- function atomicUpdater(store) {
5701
+ function atomicUpdater(store2) {
5694
5702
  return (fn) => {
5695
- store.replaceState((treeState) => {
5696
- const changeset = new TransactionInterfaceImpl(store, treeState);
5703
+ store2.replaceState((treeState) => {
5704
+ const changeset = new TransactionInterfaceImpl(store2, treeState);
5697
5705
  fn(changeset);
5698
5706
  return changeset.newTreeState_INTERNAL();
5699
5707
  });
@@ -5742,7 +5750,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5742
5750
  class Sentinel {
5743
5751
  }
5744
5752
  const SENTINEL = new Sentinel();
5745
- function recoilCallback(store, fn, args, extraInterface) {
5753
+ function recoilCallback(store2, fn, args, extraInterface) {
5746
5754
  let ret = SENTINEL;
5747
5755
  let releaseSnapshot;
5748
5756
  batchUpdates$4(() => {
@@ -5752,14 +5760,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5752
5760
  }
5753
5761
  const callbackInterface = Recoil_lazyProxy$1({
5754
5762
  ...extraInterface !== null && extraInterface !== void 0 ? extraInterface : {},
5755
- set: (node, newValue) => setRecoilValue$3(store, node, newValue),
5756
- reset: (node) => setRecoilValue$3(store, node, DEFAULT_VALUE$5),
5757
- refresh: (node) => refreshRecoilValue$1(store, node),
5758
- gotoSnapshot: (snapshot) => gotoSnapshot$1(store, snapshot),
5759
- transact_UNSTABLE: (transaction) => atomicUpdater$1(store)(transaction)
5763
+ set: (node, newValue) => setRecoilValue$3(store2, node, newValue),
5764
+ reset: (node) => setRecoilValue$3(store2, node, DEFAULT_VALUE$5),
5765
+ refresh: (node) => refreshRecoilValue$1(store2, node),
5766
+ gotoSnapshot: (snapshot) => gotoSnapshot$1(store2, snapshot),
5767
+ transact_UNSTABLE: (transaction) => atomicUpdater$1(store2)(transaction)
5760
5768
  }, {
5761
5769
  snapshot: () => {
5762
- const snapshot = cloneSnapshot$2(store);
5770
+ const snapshot = cloneSnapshot$2(store2);
5763
5771
  releaseSnapshot = snapshot.retain();
5764
5772
  return snapshot;
5765
5773
  }
@@ -5807,8 +5815,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
5807
5815
  function useRecoilRefresher(recoilValue) {
5808
5816
  const storeRef = useStoreRef$7();
5809
5817
  return useCallback$4$1(() => {
5810
- const store = storeRef.current;
5811
- refreshRecoilValue$2(store, recoilValue);
5818
+ const store2 = storeRef.current;
5819
+ refreshRecoilValue$2(store2, recoilValue);
5812
5820
  }, [recoilValue, storeRef]);
5813
5821
  }
5814
5822
  var Recoil_useRecoilRefresher = useRecoilRefresher;
@@ -6332,8 +6340,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6332
6340
  function selectorIsLive() {
6333
6341
  return !Recoil_gkx("recoil_memory_managament_2020") || liveStoresCount > 0;
6334
6342
  }
6335
- function selectorInit(store) {
6336
- store.getState().knownSelectors.add(key);
6343
+ function selectorInit(store2) {
6344
+ store2.getState().knownSelectors.add(key);
6337
6345
  liveStoresCount++;
6338
6346
  return () => {
6339
6347
  liveStoresCount--;
@@ -6342,19 +6350,19 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6342
6350
  function selectorShouldDeleteConfigOnRelease() {
6343
6351
  return getConfigDeletionHandler$1(key) !== void 0 && !selectorIsLive();
6344
6352
  }
6345
- function resolveAsync(store, state, executionID, loadable, depValues) {
6353
+ function resolveAsync(store2, state, executionID, loadable, depValues) {
6346
6354
  setCache(state, loadable, depValues);
6347
- notifyStoresOfResolvedAsync(store, executionID);
6355
+ notifyStoresOfResolvedAsync(store2, executionID);
6348
6356
  }
6349
- function notifyStoresOfResolvedAsync(store, executionID) {
6350
- if (isLatestExecution(store, executionID)) {
6351
- clearExecutionInfo(store);
6357
+ function notifyStoresOfResolvedAsync(store2, executionID) {
6358
+ if (isLatestExecution(store2, executionID)) {
6359
+ clearExecutionInfo(store2);
6352
6360
  }
6353
6361
  notifyWaitingStores(executionID, true);
6354
6362
  }
6355
- function notifyStoresOfNewAsyncDep(store, executionID) {
6356
- if (isLatestExecution(store, executionID)) {
6357
- const executionInfo = Recoil_nullthrows$1(getExecutionInfo(store));
6363
+ function notifyStoresOfNewAsyncDep(store2, executionID) {
6364
+ if (isLatestExecution(store2, executionID)) {
6365
+ const executionInfo = Recoil_nullthrows$1(getExecutionInfo(store2));
6358
6366
  executionInfo.stateVersions.clear();
6359
6367
  notifyWaitingStores(executionID, false);
6360
6368
  }
@@ -6370,52 +6378,52 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6370
6378
  }
6371
6379
  }
6372
6380
  }
6373
- function markStoreWaitingForResolvedAsync(store, executionID) {
6381
+ function markStoreWaitingForResolvedAsync(store2, executionID) {
6374
6382
  let stores = waitingStores.get(executionID);
6375
6383
  if (stores == null) {
6376
6384
  waitingStores.set(executionID, stores = /* @__PURE__ */ new Set());
6377
6385
  }
6378
- stores.add(store);
6386
+ stores.add(store2);
6379
6387
  }
6380
- function wrapResultPromise(store, promise, state, depValues, executionID, loadingDepsState) {
6388
+ function wrapResultPromise(store2, promise, state, depValues, executionID, loadingDepsState) {
6381
6389
  return promise.then((value) => {
6382
6390
  if (!selectorIsLive()) {
6383
- clearExecutionInfo(store);
6391
+ clearExecutionInfo(store2);
6384
6392
  throw CANCELED;
6385
6393
  }
6386
6394
  const loadable = loadableWithValue$2(value);
6387
- resolveAsync(store, state, executionID, loadable, depValues);
6395
+ resolveAsync(store2, state, executionID, loadable, depValues);
6388
6396
  return value;
6389
6397
  }).catch((errorOrPromise) => {
6390
6398
  if (!selectorIsLive()) {
6391
- clearExecutionInfo(store);
6399
+ clearExecutionInfo(store2);
6392
6400
  throw CANCELED;
6393
6401
  }
6394
6402
  if (Recoil_isPromise(errorOrPromise)) {
6395
- return wrapPendingDependencyPromise(store, errorOrPromise, state, depValues, executionID, loadingDepsState);
6403
+ return wrapPendingDependencyPromise(store2, errorOrPromise, state, depValues, executionID, loadingDepsState);
6396
6404
  }
6397
6405
  const loadable = loadableWithError$1(errorOrPromise);
6398
- resolveAsync(store, state, executionID, loadable, depValues);
6406
+ resolveAsync(store2, state, executionID, loadable, depValues);
6399
6407
  throw errorOrPromise;
6400
6408
  });
6401
6409
  }
6402
- function wrapPendingDependencyPromise(store, promise, state, existingDeps, executionID, loadingDepsState) {
6410
+ function wrapPendingDependencyPromise(store2, promise, state, existingDeps, executionID, loadingDepsState) {
6403
6411
  return promise.then((resolvedDep) => {
6404
6412
  if (!selectorIsLive()) {
6405
- clearExecutionInfo(store);
6413
+ clearExecutionInfo(store2);
6406
6414
  throw CANCELED;
6407
6415
  }
6408
6416
  if (loadingDepsState.loadingDepKey != null && loadingDepsState.loadingDepPromise === promise) {
6409
6417
  state.atomValues.set(loadingDepsState.loadingDepKey, loadableWithValue$2(resolvedDep));
6410
6418
  } else {
6411
- store.getState().knownSelectors.forEach((nodeKey) => {
6419
+ store2.getState().knownSelectors.forEach((nodeKey) => {
6412
6420
  state.atomValues.delete(nodeKey);
6413
6421
  });
6414
6422
  }
6415
- const cachedLoadable = getLoadableFromCacheAndUpdateDeps(store, state);
6423
+ const cachedLoadable = getLoadableFromCacheAndUpdateDeps(store2, state);
6416
6424
  if (cachedLoadable && cachedLoadable.state !== "loading") {
6417
- if (isLatestExecution(store, executionID) || getExecutionInfo(store) == null) {
6418
- notifyStoresOfResolvedAsync(store, executionID);
6425
+ if (isLatestExecution(store2, executionID) || getExecutionInfo(store2) == null) {
6426
+ notifyStoresOfResolvedAsync(store2, executionID);
6419
6427
  }
6420
6428
  if (cachedLoadable.state === "hasValue") {
6421
6429
  return cachedLoadable.contents;
@@ -6423,15 +6431,15 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6423
6431
  throw cachedLoadable.contents;
6424
6432
  }
6425
6433
  }
6426
- if (!isLatestExecution(store, executionID)) {
6427
- const executionInfo = getInProgressExecutionInfo(store, state);
6434
+ if (!isLatestExecution(store2, executionID)) {
6435
+ const executionInfo = getInProgressExecutionInfo(store2, state);
6428
6436
  if (executionInfo != null) {
6429
6437
  return executionInfo.loadingLoadable.contents;
6430
6438
  }
6431
6439
  }
6432
- const [loadable, depValues] = evaluateSelectorGetter(store, state, executionID);
6440
+ const [loadable, depValues] = evaluateSelectorGetter(store2, state, executionID);
6433
6441
  if (loadable.state !== "loading") {
6434
- resolveAsync(store, state, executionID, loadable, depValues);
6442
+ resolveAsync(store2, state, executionID, loadable, depValues);
6435
6443
  }
6436
6444
  if (loadable.state === "hasError") {
6437
6445
  throw loadable.contents;
@@ -6442,25 +6450,25 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6442
6450
  throw CANCELED;
6443
6451
  }
6444
6452
  if (!selectorIsLive()) {
6445
- clearExecutionInfo(store);
6453
+ clearExecutionInfo(store2);
6446
6454
  throw CANCELED;
6447
6455
  }
6448
6456
  const loadable = loadableWithError$1(error);
6449
- resolveAsync(store, state, executionID, loadable, existingDeps);
6457
+ resolveAsync(store2, state, executionID, loadable, existingDeps);
6450
6458
  throw error;
6451
6459
  });
6452
6460
  }
6453
- function updateDeps(store, state, deps, executionID) {
6461
+ function updateDeps(store2, state, deps, executionID) {
6454
6462
  var _store$getState, _store$getState$curre, _store$getState2, _store$getState2$next;
6455
- if (isLatestExecution(store, executionID) || state.version === ((_store$getState = store.getState()) === null || _store$getState === void 0 ? void 0 : (_store$getState$curre = _store$getState.currentTree) === null || _store$getState$curre === void 0 ? void 0 : _store$getState$curre.version) || state.version === ((_store$getState2 = store.getState()) === null || _store$getState2 === void 0 ? void 0 : (_store$getState2$next = _store$getState2.nextTree) === null || _store$getState2$next === void 0 ? void 0 : _store$getState2$next.version)) {
6463
+ if (isLatestExecution(store2, executionID) || state.version === ((_store$getState = store2.getState()) === null || _store$getState === void 0 ? void 0 : (_store$getState$curre = _store$getState.currentTree) === null || _store$getState$curre === void 0 ? void 0 : _store$getState$curre.version) || state.version === ((_store$getState2 = store2.getState()) === null || _store$getState2 === void 0 ? void 0 : (_store$getState2$next = _store$getState2.nextTree) === null || _store$getState2$next === void 0 ? void 0 : _store$getState2$next.version)) {
6456
6464
  var _store$getState$nextT, _store$getState3, _store$getState3$next;
6457
- saveDepsToStore$1(key, deps, store, (_store$getState$nextT = (_store$getState3 = store.getState()) === null || _store$getState3 === void 0 ? void 0 : (_store$getState3$next = _store$getState3.nextTree) === null || _store$getState3$next === void 0 ? void 0 : _store$getState3$next.version) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store.getState().currentTree.version);
6465
+ saveDepsToStore$1(key, deps, store2, (_store$getState$nextT = (_store$getState3 = store2.getState()) === null || _store$getState3 === void 0 ? void 0 : (_store$getState3$next = _store$getState3.nextTree) === null || _store$getState3$next === void 0 ? void 0 : _store$getState3$next.version) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store2.getState().currentTree.version);
6458
6466
  }
6459
6467
  for (const nodeKey of deps) {
6460
6468
  discoveredDependencyNodeKeys.add(nodeKey);
6461
6469
  }
6462
6470
  }
6463
- function evaluateSelectorGetter(store, state, executionID) {
6471
+ function evaluateSelectorGetter(store2, state, executionID) {
6464
6472
  const endPerfBlock = startPerfBlock$1(key);
6465
6473
  let duringSynchronousExecution = true;
6466
6474
  let duringAsynchronousExecution = true;
@@ -6479,11 +6487,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6479
6487
  function getRecoilValue({
6480
6488
  key: depKey
6481
6489
  }) {
6482
- const depLoadable = getNodeLoadable$2(store, state, depKey);
6490
+ const depLoadable = getNodeLoadable$2(store2, state, depKey);
6483
6491
  depValues.set(depKey, depLoadable);
6484
6492
  if (!duringSynchronousExecution) {
6485
- updateDeps(store, state, new Set(depValues.keys()), executionID);
6486
- notifyStoresOfNewAsyncDep(store, executionID);
6493
+ updateDeps(store2, state, new Set(depValues.keys()), executionID);
6494
+ notifyStoresOfNewAsyncDep(store2, executionID);
6487
6495
  }
6488
6496
  switch (depLoadable.state) {
6489
6497
  case "hasValue":
@@ -6504,7 +6512,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6504
6512
  }
6505
6513
  !(recoilValue != null) ? Recoil_invariant(false) : void 0;
6506
6514
  return recoilCallback$1(
6507
- store,
6515
+ store2,
6508
6516
  fn,
6509
6517
  args,
6510
6518
  {
@@ -6526,7 +6534,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6526
6534
  result = result.contents;
6527
6535
  }
6528
6536
  if (Recoil_isPromise(result)) {
6529
- result = wrapResultPromise(store, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);
6537
+ result = wrapResultPromise(store2, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);
6530
6538
  } else {
6531
6539
  finishEvaluation();
6532
6540
  }
@@ -6534,7 +6542,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6534
6542
  } catch (errorOrDepPromise) {
6535
6543
  result = errorOrDepPromise;
6536
6544
  if (Recoil_isPromise(result)) {
6537
- result = wrapPendingDependencyPromise(store, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);
6545
+ result = wrapPendingDependencyPromise(store2, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);
6538
6546
  } else {
6539
6547
  resultIsError = true;
6540
6548
  finishEvaluation();
@@ -6548,11 +6556,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6548
6556
  loadable = loadableWithValue$2(result);
6549
6557
  }
6550
6558
  duringSynchronousExecution = false;
6551
- updateExecutionInfoDepValues(store, executionID, depValues);
6552
- updateDeps(store, state, new Set(depValues.keys()), executionID);
6559
+ updateExecutionInfoDepValues(store2, executionID, depValues);
6560
+ updateDeps(store2, state, new Set(depValues.keys()), executionID);
6553
6561
  return [loadable, depValues];
6554
6562
  }
6555
- function getLoadableFromCacheAndUpdateDeps(store, state) {
6563
+ function getLoadableFromCacheAndUpdateDeps(store2, state) {
6556
6564
  let cachedLoadable = state.atomValues.get(key);
6557
6565
  if (cachedLoadable != null) {
6558
6566
  return cachedLoadable;
@@ -6561,7 +6569,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6561
6569
  try {
6562
6570
  cachedLoadable = cache2.get((nodeKey) => {
6563
6571
  !(typeof nodeKey === "string") ? false ? Recoil_invariant(false, "Cache nodeKey is type string") : Recoil_invariant(false) : void 0;
6564
- return getNodeLoadable$2(store, state, nodeKey).contents;
6572
+ return getNodeLoadable$2(store2, state, nodeKey).contents;
6565
6573
  }, {
6566
6574
  onNodeVisit: (node) => {
6567
6575
  if (node.type === "branch" && node.nodeKey !== key) {
@@ -6575,40 +6583,40 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6575
6583
  if (cachedLoadable) {
6576
6584
  var _getExecutionInfo;
6577
6585
  state.atomValues.set(key, cachedLoadable);
6578
- updateDeps(store, state, depsAfterCacheLookup, (_getExecutionInfo = getExecutionInfo(store)) === null || _getExecutionInfo === void 0 ? void 0 : _getExecutionInfo.executionID);
6586
+ updateDeps(store2, state, depsAfterCacheLookup, (_getExecutionInfo = getExecutionInfo(store2)) === null || _getExecutionInfo === void 0 ? void 0 : _getExecutionInfo.executionID);
6579
6587
  }
6580
6588
  return cachedLoadable;
6581
6589
  }
6582
- function getSelectorLoadableAndUpdateDeps(store, state) {
6583
- const cachedVal = getLoadableFromCacheAndUpdateDeps(store, state);
6590
+ function getSelectorLoadableAndUpdateDeps(store2, state) {
6591
+ const cachedVal = getLoadableFromCacheAndUpdateDeps(store2, state);
6584
6592
  if (cachedVal != null) {
6585
- clearExecutionInfo(store);
6593
+ clearExecutionInfo(store2);
6586
6594
  return cachedVal;
6587
6595
  }
6588
- const inProgressExecutionInfo = getInProgressExecutionInfo(store, state);
6596
+ const inProgressExecutionInfo = getInProgressExecutionInfo(store2, state);
6589
6597
  if (inProgressExecutionInfo != null) {
6590
6598
  var _inProgressExecutionI;
6591
6599
  if (((_inProgressExecutionI = inProgressExecutionInfo.loadingLoadable) === null || _inProgressExecutionI === void 0 ? void 0 : _inProgressExecutionI.state) === "loading") {
6592
- markStoreWaitingForResolvedAsync(store, inProgressExecutionInfo.executionID);
6600
+ markStoreWaitingForResolvedAsync(store2, inProgressExecutionInfo.executionID);
6593
6601
  }
6594
6602
  return inProgressExecutionInfo.loadingLoadable;
6595
6603
  }
6596
6604
  const newExecutionID = getNewExecutionID();
6597
- const [loadable, newDepValues] = evaluateSelectorGetter(store, state, newExecutionID);
6605
+ const [loadable, newDepValues] = evaluateSelectorGetter(store2, state, newExecutionID);
6598
6606
  if (loadable.state === "loading") {
6599
- setExecutionInfo(store, newExecutionID, loadable, newDepValues, state);
6600
- markStoreWaitingForResolvedAsync(store, newExecutionID);
6607
+ setExecutionInfo(store2, newExecutionID, loadable, newDepValues, state);
6608
+ markStoreWaitingForResolvedAsync(store2, newExecutionID);
6601
6609
  } else {
6602
- clearExecutionInfo(store);
6610
+ clearExecutionInfo(store2);
6603
6611
  setCache(state, loadable, newDepValues);
6604
6612
  }
6605
6613
  return loadable;
6606
6614
  }
6607
- function getInProgressExecutionInfo(store, state) {
6608
- const pendingExecutions = Recoil_concatIterables([executionInfoMap.has(store) ? [Recoil_nullthrows$1(executionInfoMap.get(store))] : [], Recoil_mapIterable(Recoil_filterIterable(executionInfoMap, ([s]) => s !== store), ([, execInfo]) => execInfo)]);
6615
+ function getInProgressExecutionInfo(store2, state) {
6616
+ const pendingExecutions = Recoil_concatIterables([executionInfoMap.has(store2) ? [Recoil_nullthrows$1(executionInfoMap.get(store2))] : [], Recoil_mapIterable(Recoil_filterIterable(executionInfoMap, ([s]) => s !== store2), ([, execInfo]) => execInfo)]);
6609
6617
  function anyDepChanged(execDepValues) {
6610
6618
  for (const [depKey, execLoadable] of execDepValues) {
6611
- if (!getNodeLoadable$2(store, state, depKey).is(execLoadable)) {
6619
+ if (!getNodeLoadable$2(store2, state, depKey).is(execLoadable)) {
6612
6620
  return true;
6613
6621
  }
6614
6622
  }
@@ -6624,31 +6632,31 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6624
6632
  }
6625
6633
  return void 0;
6626
6634
  }
6627
- function getExecutionInfo(store) {
6628
- return executionInfoMap.get(store);
6635
+ function getExecutionInfo(store2) {
6636
+ return executionInfoMap.get(store2);
6629
6637
  }
6630
- function setExecutionInfo(store, newExecutionID, loadable, depValues, state) {
6631
- executionInfoMap.set(store, {
6638
+ function setExecutionInfo(store2, newExecutionID, loadable, depValues, state) {
6639
+ executionInfoMap.set(store2, {
6632
6640
  depValuesDiscoveredSoFarDuringAsyncWork: depValues,
6633
6641
  executionID: newExecutionID,
6634
6642
  loadingLoadable: loadable,
6635
6643
  stateVersions: /* @__PURE__ */ new Map([[state.version, true]])
6636
6644
  });
6637
6645
  }
6638
- function updateExecutionInfoDepValues(store, executionID, depValues) {
6639
- if (isLatestExecution(store, executionID)) {
6640
- const executionInfo = getExecutionInfo(store);
6646
+ function updateExecutionInfoDepValues(store2, executionID, depValues) {
6647
+ if (isLatestExecution(store2, executionID)) {
6648
+ const executionInfo = getExecutionInfo(store2);
6641
6649
  if (executionInfo != null) {
6642
6650
  executionInfo.depValuesDiscoveredSoFarDuringAsyncWork = depValues;
6643
6651
  }
6644
6652
  }
6645
6653
  }
6646
- function clearExecutionInfo(store) {
6647
- executionInfoMap.delete(store);
6654
+ function clearExecutionInfo(store2) {
6655
+ executionInfoMap.delete(store2);
6648
6656
  }
6649
- function isLatestExecution(store, executionID) {
6657
+ function isLatestExecution(store2, executionID) {
6650
6658
  var _getExecutionInfo2;
6651
- return executionID === ((_getExecutionInfo2 = getExecutionInfo(store)) === null || _getExecutionInfo2 === void 0 ? void 0 : _getExecutionInfo2.executionID);
6659
+ return executionID === ((_getExecutionInfo2 = getExecutionInfo(store2)) === null || _getExecutionInfo2 === void 0 ? void 0 : _getExecutionInfo2.executionID);
6652
6660
  }
6653
6661
  function depValuesToDepRoute(depValues) {
6654
6662
  return Array.from(depValues.entries()).map(([depKey, valLoadable]) => [depKey, valLoadable.contents]);
@@ -6673,7 +6681,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6673
6681
  dependencyStack.pop();
6674
6682
  }
6675
6683
  }
6676
- function selectorPeek(store, state) {
6684
+ function selectorPeek(store2, state) {
6677
6685
  const cachedLoadable = state.atomValues.get(key);
6678
6686
  if (cachedLoadable != null) {
6679
6687
  return cachedLoadable;
@@ -6681,29 +6689,29 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6681
6689
  return cache2.get((nodeKey) => {
6682
6690
  var _peekNodeLoadable;
6683
6691
  !(typeof nodeKey === "string") ? Recoil_invariant(false) : void 0;
6684
- return (_peekNodeLoadable = peekNodeLoadable$1(store, state, nodeKey)) === null || _peekNodeLoadable === void 0 ? void 0 : _peekNodeLoadable.contents;
6692
+ return (_peekNodeLoadable = peekNodeLoadable$1(store2, state, nodeKey)) === null || _peekNodeLoadable === void 0 ? void 0 : _peekNodeLoadable.contents;
6685
6693
  });
6686
6694
  }
6687
- function selectorGet(store, state) {
6688
- return detectCircularDependencies(() => getSelectorLoadableAndUpdateDeps(store, state));
6695
+ function selectorGet(store2, state) {
6696
+ return detectCircularDependencies(() => getSelectorLoadableAndUpdateDeps(store2, state));
6689
6697
  }
6690
6698
  function invalidateSelector(state) {
6691
6699
  state.atomValues.delete(key);
6692
6700
  }
6693
- function clearSelectorCache(store, treeState) {
6701
+ function clearSelectorCache(store2, treeState) {
6694
6702
  !(recoilValue != null) ? Recoil_invariant(false) : void 0;
6695
6703
  for (const nodeKey of discoveredDependencyNodeKeys) {
6696
6704
  var _node$clearCache;
6697
6705
  const node = getNode$6(nodeKey);
6698
- (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store, treeState);
6706
+ (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store2, treeState);
6699
6707
  }
6700
6708
  discoveredDependencyNodeKeys.clear();
6701
6709
  invalidateSelector(treeState);
6702
6710
  cache2.clear();
6703
- markRecoilValueModified$1(store, recoilValue);
6711
+ markRecoilValueModified$1(store2, recoilValue);
6704
6712
  }
6705
6713
  if (set2 != null) {
6706
- const selectorSet = (store, state, newValue) => {
6714
+ const selectorSet = (store2, state, newValue) => {
6707
6715
  let syncSelectorSetFinished = false;
6708
6716
  const writes = /* @__PURE__ */ new Map();
6709
6717
  function getRecoilValue({
@@ -6712,7 +6720,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6712
6720
  if (syncSelectorSetFinished) {
6713
6721
  throw Recoil_err$2("Recoil: Async selector sets are not currently supported.");
6714
6722
  }
6715
- const loadable = getNodeLoadable$2(store, state, depKey);
6723
+ const loadable = getNodeLoadable$2(store2, state, depKey);
6716
6724
  if (loadable.state === "hasValue") {
6717
6725
  return loadable.contents;
6718
6726
  } else if (loadable.state === "loading") {
@@ -6728,7 +6736,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6728
6736
  throw Recoil_err$2(msg);
6729
6737
  }
6730
6738
  const setValue = typeof valueOrUpdater === "function" ? valueOrUpdater(getRecoilValue(recoilState)) : valueOrUpdater;
6731
- const upstreamWrites = setNodeValue$3(store, state, recoilState.key, setValue);
6739
+ const upstreamWrites = setNodeValue$3(store2, state, recoilState.key, setValue);
6732
6740
  upstreamWrites.forEach((v2, k2) => writes.set(k2, v2));
6733
6741
  }
6734
6742
  function resetRecoilState(recoilState) {
@@ -6832,40 +6840,40 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6832
6840
  function maybeFreezeValueOrPromise(valueOrPromise) {
6833
6841
  return valueOrPromise;
6834
6842
  }
6835
- function wrapPendingPromise(store, promise) {
6843
+ function wrapPendingPromise(store2, promise) {
6836
6844
  const wrappedPromise = promise.then((value) => {
6837
6845
  var _store$getState$nextT, _state$atomValues$get;
6838
- const state = (_store$getState$nextT = store.getState().nextTree) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store.getState().currentTree;
6846
+ const state = (_store$getState$nextT = store2.getState().nextTree) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store2.getState().currentTree;
6839
6847
  if (((_state$atomValues$get = state.atomValues.get(key)) === null || _state$atomValues$get === void 0 ? void 0 : _state$atomValues$get.contents) === wrappedPromise) {
6840
- setRecoilValue$4(store, node, value);
6848
+ setRecoilValue$4(store2, node, value);
6841
6849
  }
6842
6850
  return value;
6843
6851
  }).catch((error) => {
6844
6852
  var _store$getState$nextT2, _state$atomValues$get2;
6845
- const state = (_store$getState$nextT2 = store.getState().nextTree) !== null && _store$getState$nextT2 !== void 0 ? _store$getState$nextT2 : store.getState().currentTree;
6853
+ const state = (_store$getState$nextT2 = store2.getState().nextTree) !== null && _store$getState$nextT2 !== void 0 ? _store$getState$nextT2 : store2.getState().currentTree;
6846
6854
  if (((_state$atomValues$get2 = state.atomValues.get(key)) === null || _state$atomValues$get2 === void 0 ? void 0 : _state$atomValues$get2.contents) === wrappedPromise) {
6847
- setRecoilValueLoadable$2(store, node, loadableWithError$2(error));
6855
+ setRecoilValueLoadable$2(store2, node, loadableWithError$2(error));
6848
6856
  }
6849
6857
  throw error;
6850
6858
  });
6851
6859
  return wrappedPromise;
6852
6860
  }
6853
- function initAtom(store, initState, trigger) {
6861
+ function initAtom(store2, initState, trigger) {
6854
6862
  var _options$effects;
6855
6863
  liveStoresCount++;
6856
6864
  const cleanupAtom = () => {
6857
6865
  var _cleanupEffectsByStor;
6858
6866
  liveStoresCount--;
6859
- (_cleanupEffectsByStor = cleanupEffectsByStore.get(store)) === null || _cleanupEffectsByStor === void 0 ? void 0 : _cleanupEffectsByStor.forEach((cleanup) => cleanup());
6860
- cleanupEffectsByStore.delete(store);
6867
+ (_cleanupEffectsByStor = cleanupEffectsByStore.get(store2)) === null || _cleanupEffectsByStor === void 0 ? void 0 : _cleanupEffectsByStor.forEach((cleanup) => cleanup());
6868
+ cleanupEffectsByStore.delete(store2);
6861
6869
  };
6862
- store.getState().knownAtoms.add(key);
6870
+ store2.getState().knownAtoms.add(key);
6863
6871
  if (defaultLoadable.state === "loading") {
6864
6872
  const notifyDefaultSubscribers = () => {
6865
6873
  var _store$getState$nextT3;
6866
- const state = (_store$getState$nextT3 = store.getState().nextTree) !== null && _store$getState$nextT3 !== void 0 ? _store$getState$nextT3 : store.getState().currentTree;
6874
+ const state = (_store$getState$nextT3 = store2.getState().nextTree) !== null && _store$getState$nextT3 !== void 0 ? _store$getState$nextT3 : store2.getState().currentTree;
6867
6875
  if (!state.atomValues.has(key)) {
6868
- markRecoilValueModified$2(store, node);
6876
+ markRecoilValueModified$2(store2, node);
6869
6877
  }
6870
6878
  };
6871
6879
  defaultLoadable.contents.finally(notifyDefaultSubscribers);
@@ -6875,14 +6883,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6875
6883
  let getLoadable = function(recoilValue) {
6876
6884
  if (isDuringInit && recoilValue.key === key) {
6877
6885
  const retValue = initValue;
6878
- return retValue instanceof DefaultValue$2$1 ? peekAtom(store, initState) : Recoil_isPromise(retValue) ? loadableWithPromise$2(retValue.then((v2) => v2 instanceof DefaultValue$2$1 ? defaultLoadable.toPromise() : v2)) : loadableWithValue$3(retValue);
6886
+ return retValue instanceof DefaultValue$2$1 ? peekAtom(store2, initState) : Recoil_isPromise(retValue) ? loadableWithPromise$2(retValue.then((v2) => v2 instanceof DefaultValue$2$1 ? defaultLoadable.toPromise() : v2)) : loadableWithValue$3(retValue);
6879
6887
  }
6880
- return getRecoilValueAsLoadable$4(store, recoilValue);
6888
+ return getRecoilValueAsLoadable$4(store2, recoilValue);
6881
6889
  }, getPromise = function(recoilValue) {
6882
6890
  return getLoadable(recoilValue).toPromise();
6883
6891
  }, getInfo_UNSTABLE = function(recoilValue) {
6884
6892
  var _store$getState$nextT4;
6885
- const info = peekNodeInfo$3(store, (_store$getState$nextT4 = store.getState().nextTree) !== null && _store$getState$nextT4 !== void 0 ? _store$getState$nextT4 : store.getState().currentTree, recoilValue.key);
6893
+ const info = peekNodeInfo$3(store2, (_store$getState$nextT4 = store2.getState().nextTree) !== null && _store$getState$nextT4 !== void 0 ? _store$getState$nextT4 : store2.getState().currentTree, recoilValue.key);
6886
6894
  return isDuringInit && recoilValue.key === key && !(initValue instanceof DefaultValue$2$1) ? {
6887
6895
  ...info,
6888
6896
  isSet: true,
@@ -6917,7 +6925,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6917
6925
  value: unwrap(valueOrUpdater)
6918
6926
  };
6919
6927
  }
6920
- setRecoilValue$4(store, node, typeof valueOrUpdater === "function" ? (currentValue) => {
6928
+ setRecoilValue$4(store2, node, typeof valueOrUpdater === "function" ? (currentValue) => {
6921
6929
  const newValue = unwrap(
6922
6930
  valueOrUpdater(currentValue)
6923
6931
  );
@@ -6934,7 +6942,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6934
6942
  var _cleanupEffectsByStor2;
6935
6943
  const {
6936
6944
  release
6937
- } = store.subscribeToTransactions((currentStore) => {
6945
+ } = store2.subscribeToTransactions((currentStore) => {
6938
6946
  var _currentTree$atomValu;
6939
6947
  let {
6940
6948
  currentTree,
@@ -6956,14 +6964,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6956
6964
  }
6957
6965
  }
6958
6966
  }, key);
6959
- cleanupEffectsByStore.set(store, [...(_cleanupEffectsByStor2 = cleanupEffectsByStore.get(store)) !== null && _cleanupEffectsByStor2 !== void 0 ? _cleanupEffectsByStor2 : [], release]);
6967
+ cleanupEffectsByStore.set(store2, [...(_cleanupEffectsByStor2 = cleanupEffectsByStore.get(store2)) !== null && _cleanupEffectsByStor2 !== void 0 ? _cleanupEffectsByStor2 : [], release]);
6960
6968
  };
6961
6969
  for (const effect2 of effects) {
6962
6970
  try {
6963
6971
  const cleanup = effect2({
6964
6972
  node,
6965
- storeID: store.storeID,
6966
- parentStoreID_UNSTABLE: store.parentStoreID,
6973
+ storeID: store2.storeID,
6974
+ parentStoreID_UNSTABLE: store2.parentStoreID,
6967
6975
  trigger,
6968
6976
  setSelf: setSelf(effect2),
6969
6977
  resetSelf: resetSelf(effect2),
@@ -6974,7 +6982,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6974
6982
  });
6975
6983
  if (cleanup != null) {
6976
6984
  var _cleanupEffectsByStor3;
6977
- cleanupEffectsByStore.set(store, [...(_cleanupEffectsByStor3 = cleanupEffectsByStore.get(store)) !== null && _cleanupEffectsByStor3 !== void 0 ? _cleanupEffectsByStor3 : [], cleanup]);
6985
+ cleanupEffectsByStore.set(store2, [...(_cleanupEffectsByStor3 = cleanupEffectsByStore.get(store2)) !== null && _cleanupEffectsByStor3 !== void 0 ? _cleanupEffectsByStor3 : [], cleanup]);
6978
6986
  }
6979
6987
  } catch (error) {
6980
6988
  initValue = error;
@@ -6984,10 +6992,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
6984
6992
  isDuringInit = false;
6985
6993
  if (!(initValue instanceof DefaultValue$2$1)) {
6986
6994
  var _store$getState$nextT5;
6987
- const initLoadable = isInitError ? loadableWithError$2(initValue) : Recoil_isPromise(initValue) ? loadableWithPromise$2(wrapPendingPromise(store, initValue)) : loadableWithValue$3(unwrap(initValue));
6995
+ const initLoadable = isInitError ? loadableWithError$2(initValue) : Recoil_isPromise(initValue) ? loadableWithPromise$2(wrapPendingPromise(store2, initValue)) : loadableWithValue$3(unwrap(initValue));
6988
6996
  maybeFreezeValueOrPromise(initLoadable.contents);
6989
6997
  initState.atomValues.set(key, initLoadable);
6990
- (_store$getState$nextT5 = store.getState().nextTree) === null || _store$getState$nextT5 === void 0 ? void 0 : _store$getState$nextT5.atomValues.set(key, initLoadable);
6998
+ (_store$getState$nextT5 = store2.getState().nextTree) === null || _store$getState$nextT5 === void 0 ? void 0 : _store$getState$nextT5.atomValues.set(key, initLoadable);
6991
6999
  }
6992
7000
  }
6993
7001
  return cleanupAtom;
@@ -10754,10 +10762,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
10754
10762
  };
10755
10763
  const read2 = (itemKey) => diff.has(itemKey) ? diff.get(itemKey) : readFromStorageRequired(itemKey);
10756
10764
  const write2 = (k2, l2) => void diff.set(k2, l2);
10757
- const reset2 = (k2) => void diff.set(k2, DEFAULT_VALUE);
10765
+ const reset = (k2) => void diff.set(k2, DEFAULT_VALUE);
10758
10766
  options.write({
10759
10767
  write: write2,
10760
- reset: reset2,
10768
+ reset,
10761
10769
  read: read2
10762
10770
  }, loadable == null ? DEFAULT_VALUE : loadable.contents);
10763
10771
  return diff;
@@ -10824,7 +10832,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
10824
10832
  }, [read2, recoilStoreID, snapshot, storeKey, write2]);
10825
10833
  const updateItems = useRecoilTransaction_UNSTABLE(({
10826
10834
  set: set2,
10827
- reset: reset2
10835
+ reset
10828
10836
  }) => (diff) => {
10829
10837
  const atomRegistry2 = registries.getAtomRegistry(recoilStoreID, storeKey);
10830
10838
  for (const [, atomRegistration] of atomRegistry2) {
@@ -10842,7 +10850,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
10842
10850
  atomRegistration.pendingUpdate = {
10843
10851
  value: DEFAULT_VALUE
10844
10852
  };
10845
- reset2(atomRegistration.atom);
10853
+ reset(atomRegistration.atom);
10846
10854
  } else {
10847
10855
  atomRegistration.pendingUpdate = {
10848
10856
  value: loadable.contents
@@ -10855,7 +10863,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
10855
10863
  atomRegistration.pendingUpdate = {
10856
10864
  value: DEFAULT_VALUE
10857
10865
  };
10858
- reset2(atomRegistration.atom);
10866
+ reset(atomRegistration.atom);
10859
10867
  }
10860
10868
  break;
10861
10869
  case "loading":
@@ -10866,7 +10874,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
10866
10874
  atomRegistration.pendingUpdate = {
10867
10875
  value: DEFAULT_VALUE
10868
10876
  };
10869
- reset2(atomRegistration.atom);
10877
+ reset(atomRegistration.atom);
10870
10878
  }
10871
10879
  }
10872
10880
  }
@@ -12731,7 +12739,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
12731
12739
  });
12732
12740
  var _require = Collapse$2, Collapse = _require.Collapse;
12733
12741
  var _require2 = UnmountClosed$2, UnmountClosed = _require2.UnmountClosed;
12734
- var lib$1 = UnmountClosed;
12742
+ var lib = UnmountClosed;
12735
12743
  UnmountClosed.Collapse = Collapse;
12736
12744
  UnmountClosed.UnmountClosed = UnmountClosed;
12737
12745
  var faToggleOff = {
@@ -13429,17 +13437,17 @@ var __privateWrapper = (obj, member, setter, getter) => ({
13429
13437
  };
13430
13438
  function ucs2decode(string2) {
13431
13439
  var output = [];
13432
- var counter2 = 0;
13440
+ var counter = 0;
13433
13441
  var length = string2.length;
13434
- while (counter2 < length) {
13435
- var value = string2.charCodeAt(counter2++);
13436
- if (value >= 55296 && value <= 56319 && counter2 < length) {
13437
- var extra = string2.charCodeAt(counter2++);
13442
+ while (counter < length) {
13443
+ var value = string2.charCodeAt(counter++);
13444
+ if (value >= 55296 && value <= 56319 && counter < length) {
13445
+ var extra = string2.charCodeAt(counter++);
13438
13446
  if ((extra & 64512) == 56320) {
13439
13447
  output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
13440
13448
  } else {
13441
13449
  output.push(value);
13442
- counter2--;
13450
+ counter--;
13443
13451
  }
13444
13452
  } else {
13445
13453
  output.push(value);
@@ -13511,14 +13519,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
13511
13519
  return null;
13512
13520
  }
13513
13521
  }
13514
- var build$2 = function build2() {
13515
- var lookup2 = function lookup3(reducer2) {
13522
+ var build$1 = function build2() {
13523
+ var lookup = function lookup2(reducer2) {
13516
13524
  return reduce(styles, function(o2, style, prefix2) {
13517
13525
  o2[prefix2] = reduce(style, reducer2, {});
13518
13526
  return o2;
13519
13527
  }, {});
13520
13528
  };
13521
- _byUnicode = lookup2(function(acc, icon2, iconName) {
13529
+ _byUnicode = lookup(function(acc, icon2, iconName) {
13522
13530
  if (icon2[3]) {
13523
13531
  acc[icon2[3]] = iconName;
13524
13532
  }
@@ -13532,7 +13540,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
13532
13540
  }
13533
13541
  return acc;
13534
13542
  });
13535
- _byLigature = lookup2(function(acc, icon2, iconName) {
13543
+ _byLigature = lookup(function(acc, icon2, iconName) {
13536
13544
  acc[iconName] = iconName;
13537
13545
  if (icon2[2]) {
13538
13546
  var aliases = icon2[2].filter(function(a2) {
@@ -13544,7 +13552,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
13544
13552
  }
13545
13553
  return acc;
13546
13554
  });
13547
- _byAlias = lookup2(function(acc, icon2, iconName) {
13555
+ _byAlias = lookup(function(acc, icon2, iconName) {
13548
13556
  var aliases = icon2[2];
13549
13557
  acc[iconName] = iconName;
13550
13558
  aliases.forEach(function(alias) {
@@ -13588,7 +13596,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
13588
13596
  family: config$1.familyDefault
13589
13597
  });
13590
13598
  });
13591
- build$2();
13599
+ build$1();
13592
13600
  function byUnicode(prefix2, unicode) {
13593
13601
  return (_byUnicode[prefix2] || {})[unicode];
13594
13602
  }
@@ -13715,12 +13723,12 @@ var __privateWrapper = (obj, member, setter, getter) => ({
13715
13723
  var longPrefix = PREFIX_TO_LONG_STYLE[FAMILY_CLASSIC][key];
13716
13724
  if (longPrefix)
13717
13725
  defineIcons(longPrefix, additions[key]);
13718
- build$2();
13726
+ build$1();
13719
13727
  });
13720
13728
  }
13721
13729
  }, {
13722
13730
  key: "reset",
13723
- value: function reset2() {
13731
+ value: function reset() {
13724
13732
  this.definitions = {};
13725
13733
  }
13726
13734
  }, {
@@ -14743,7 +14751,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
14743
14751
  var LayersCounter = {
14744
14752
  mixout: function mixout() {
14745
14753
  return {
14746
- counter: function counter2(content) {
14754
+ counter: function counter(content) {
14747
14755
  var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
14748
14756
  var _params$title = params.title, title = _params$title === void 0 ? null : _params$title, _params$classes = params.classes, classes = _params$classes === void 0 ? [] : _params$classes, _params$attributes = params.attributes, attributes = _params$attributes === void 0 ? {} : _params$attributes, _params$styles = params.styles, styles2 = _params$styles === void 0 ? {} : _params$styles;
14749
14757
  return domVariants({
@@ -15958,208 +15966,19 @@ var __privateWrapper = (obj, member, setter, getter) => ({
15958
15966
  }
15959
15967
  return status === Status.SUCCESS ? colors.success : colors.primary;
15960
15968
  };
15961
- var shortid$1 = { exports: {} };
15962
- var lib = { exports: {} };
15963
- var seed = 1;
15964
- function getNextValue$1() {
15965
- seed = (seed * 9301 + 49297) % 233280;
15966
- return seed / 233280;
15967
- }
15968
- function setSeed$1(_seed_) {
15969
- seed = _seed_;
15970
- }
15971
- var randomFromSeed$1 = {
15972
- nextValue: getNextValue$1,
15973
- seed: setSeed$1
15974
- };
15975
- var randomFromSeed = randomFromSeed$1;
15976
- var ORIGINAL = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-";
15977
- var alphabet$2;
15978
- var previousSeed;
15979
- var shuffled;
15980
- function reset() {
15981
- shuffled = false;
15982
- }
15983
- function setCharacters(_alphabet_) {
15984
- if (!_alphabet_) {
15985
- if (alphabet$2 !== ORIGINAL) {
15986
- alphabet$2 = ORIGINAL;
15987
- reset();
15988
- }
15989
- return;
15990
- }
15991
- if (_alphabet_ === alphabet$2) {
15992
- return;
15993
- }
15994
- if (_alphabet_.length !== ORIGINAL.length) {
15995
- throw new Error("Custom alphabet for shortid must be " + ORIGINAL.length + " unique characters. You submitted " + _alphabet_.length + " characters: " + _alphabet_);
15996
- }
15997
- var unique2 = _alphabet_.split("").filter(function(item, ind, arr) {
15998
- return ind !== arr.lastIndexOf(item);
15999
- });
16000
- if (unique2.length) {
16001
- throw new Error("Custom alphabet for shortid must be " + ORIGINAL.length + " unique characters. These characters were not unique: " + unique2.join(", "));
16002
- }
16003
- alphabet$2 = _alphabet_;
16004
- reset();
16005
- }
16006
- function characters(_alphabet_) {
16007
- setCharacters(_alphabet_);
16008
- return alphabet$2;
16009
- }
16010
- function setSeed(seed2) {
16011
- randomFromSeed.seed(seed2);
16012
- if (previousSeed !== seed2) {
16013
- reset();
16014
- previousSeed = seed2;
16015
- }
16016
- }
16017
- function shuffle() {
16018
- if (!alphabet$2) {
16019
- setCharacters(ORIGINAL);
16020
- }
16021
- var sourceArray = alphabet$2.split("");
16022
- var targetArray = [];
16023
- var r2 = randomFromSeed.nextValue();
16024
- var characterIndex;
16025
- while (sourceArray.length > 0) {
16026
- r2 = randomFromSeed.nextValue();
16027
- characterIndex = Math.floor(r2 * sourceArray.length);
16028
- targetArray.push(sourceArray.splice(characterIndex, 1)[0]);
16029
- }
16030
- return targetArray.join("");
16031
- }
16032
- function getShuffled() {
16033
- if (shuffled) {
16034
- return shuffled;
16035
- }
16036
- shuffled = shuffle();
16037
- return shuffled;
16038
- }
16039
- function lookup(index2) {
16040
- var alphabetShuffled = getShuffled();
16041
- return alphabetShuffled[index2];
16042
- }
16043
- function get$2() {
16044
- return alphabet$2 || ORIGINAL;
16045
- }
16046
- var alphabet_1 = {
16047
- get: get$2,
16048
- characters,
16049
- seed: setSeed,
16050
- lookup,
16051
- shuffled: getShuffled
16052
- };
16053
- var crypto$1 = typeof window === "object" && (window.crypto || window.msCrypto);
16054
- var randomByte;
16055
- if (!crypto$1 || !crypto$1.getRandomValues) {
16056
- randomByte = function(size2) {
16057
- var bytes = [];
16058
- for (var i2 = 0; i2 < size2; i2++) {
16059
- bytes.push(Math.floor(Math.random() * 256));
16060
- }
16061
- return bytes;
16062
- };
16063
- } else {
16064
- randomByte = function(size2) {
16065
- return crypto$1.getRandomValues(new Uint8Array(size2));
16066
- };
16067
- }
16068
- var randomByteBrowser = randomByte;
16069
- var format_browser = function(random2, alphabet2, size2) {
16070
- var mask = (2 << Math.log(alphabet2.length - 1) / Math.LN2) - 1;
16071
- var step = -~(1.6 * mask * size2 / alphabet2.length);
16072
- var id = "";
16073
- while (true) {
16074
- var bytes = random2(step);
16075
- var i2 = step;
16076
- while (i2--) {
16077
- id += alphabet2[bytes[i2] & mask] || "";
16078
- if (id.length === +size2)
16079
- return id;
16080
- }
16081
- }
16082
- };
16083
- var alphabet$1 = alphabet_1;
16084
- var random = randomByteBrowser;
16085
- var format$2 = format_browser;
16086
- function generate$1(number2) {
16087
- var loopCounter = 0;
16088
- var done;
16089
- var str = "";
16090
- while (!done) {
16091
- str = str + format$2(random, alphabet$1.get(), 1);
16092
- done = number2 < Math.pow(16, loopCounter + 1);
16093
- loopCounter++;
16094
- }
16095
- return str;
16096
- }
16097
- var generate_1 = generate$1;
16098
- var generate = generate_1;
16099
- var REDUCE_TIME = 1567752802062;
16100
- var version = 7;
16101
- var counter;
16102
- var previousSeconds;
16103
- function build$1(clusterWorkerId) {
16104
- var str = "";
16105
- var seconds = Math.floor((Date.now() - REDUCE_TIME) * 1e-3);
16106
- if (seconds === previousSeconds) {
16107
- counter++;
15969
+ let nanoid = (size2 = 21) => crypto.getRandomValues(new Uint8Array(size2)).reduce((id, byte) => {
15970
+ byte &= 63;
15971
+ if (byte < 36) {
15972
+ id += byte.toString(36);
15973
+ } else if (byte < 62) {
15974
+ id += (byte - 26).toString(36).toUpperCase();
15975
+ } else if (byte > 62) {
15976
+ id += "-";
16108
15977
  } else {
16109
- counter = 0;
16110
- previousSeconds = seconds;
16111
- }
16112
- str = str + generate(version);
16113
- str = str + generate(clusterWorkerId);
16114
- if (counter > 0) {
16115
- str = str + generate(counter);
16116
- }
16117
- str = str + generate(seconds);
16118
- return str;
16119
- }
16120
- var build_1 = build$1;
16121
- var alphabet = alphabet_1;
16122
- function isShortId(id) {
16123
- if (!id || typeof id !== "string" || id.length < 6) {
16124
- return false;
15978
+ id += "_";
16125
15979
  }
16126
- var nonAlphabetic = new RegExp("[^" + alphabet.get().replace(/[|\\{}()[\]^$+*?.-]/g, "\\$&") + "]");
16127
- return !nonAlphabetic.test(id);
16128
- }
16129
- var isValid$2 = isShortId;
16130
- (function(module2) {
16131
- var alphabet2 = alphabet_1;
16132
- var build2 = build_1;
16133
- var isValid2 = isValid$2;
16134
- var clusterWorkerId = 0;
16135
- function seed2(seedValue) {
16136
- alphabet2.seed(seedValue);
16137
- return module2.exports;
16138
- }
16139
- function worker(workerId) {
16140
- clusterWorkerId = workerId;
16141
- return module2.exports;
16142
- }
16143
- function characters2(newCharacters) {
16144
- if (newCharacters !== void 0) {
16145
- alphabet2.characters(newCharacters);
16146
- }
16147
- return alphabet2.shuffled();
16148
- }
16149
- function generate2() {
16150
- return build2(clusterWorkerId);
16151
- }
16152
- module2.exports = generate2;
16153
- module2.exports.generate = generate2;
16154
- module2.exports.seed = seed2;
16155
- module2.exports.worker = worker;
16156
- module2.exports.characters = characters2;
16157
- module2.exports.isValid = isValid2;
16158
- })(lib);
16159
- (function(module2) {
16160
- module2.exports = lib.exports;
16161
- })(shortid$1);
16162
- const shortid = /* @__PURE__ */ getDefaultExportFromCjs(shortid$1.exports);
15980
+ return id;
15981
+ }, "");
16163
15982
  var __awaiter$1 = globalThis && globalThis.__awaiter || function(thisArg, _arguments, P, generator) {
16164
15983
  function adopt(value) {
16165
15984
  return value instanceof P ? value : new P(function(resolve) {
@@ -17319,6 +17138,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
17319
17138
  step((generator = generator.apply(thisArg, _arguments || [])).next());
17320
17139
  });
17321
17140
  };
17141
+ function hasWindow() {
17142
+ return typeof window !== "undefined";
17143
+ }
17322
17144
  function getNodeName$1(node) {
17323
17145
  if (isNode(node)) {
17324
17146
  return (node.nodeName || "").toLowerCase();
@@ -17334,16 +17156,25 @@ var __privateWrapper = (obj, member, setter, getter) => ({
17334
17156
  return (_ref2 = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref2.documentElement;
17335
17157
  }
17336
17158
  function isNode(value) {
17159
+ if (!hasWindow()) {
17160
+ return false;
17161
+ }
17337
17162
  return value instanceof Node || value instanceof getWindow$1(value).Node;
17338
17163
  }
17339
17164
  function isElement$3(value) {
17165
+ if (!hasWindow()) {
17166
+ return false;
17167
+ }
17340
17168
  return value instanceof Element || value instanceof getWindow$1(value).Element;
17341
17169
  }
17342
17170
  function isHTMLElement$1(value) {
17171
+ if (!hasWindow()) {
17172
+ return false;
17173
+ }
17343
17174
  return value instanceof HTMLElement || value instanceof getWindow$1(value).HTMLElement;
17344
17175
  }
17345
17176
  function isShadowRoot$1(value) {
17346
- if (typeof ShadowRoot === "undefined") {
17177
+ if (!hasWindow() || typeof ShadowRoot === "undefined") {
17347
17178
  return false;
17348
17179
  }
17349
17180
  return value instanceof ShadowRoot || value instanceof getWindow$1(value).ShadowRoot;
@@ -17369,19 +17200,18 @@ var __privateWrapper = (obj, member, setter, getter) => ({
17369
17200
  }
17370
17201
  });
17371
17202
  }
17372
- function isContainingBlock(element) {
17203
+ function isContainingBlock(elementOrCss) {
17373
17204
  const webkit = isWebKit();
17374
- const css2 = getComputedStyle$2(element);
17205
+ const css2 = isElement$3(elementOrCss) ? getComputedStyle$2(elementOrCss) : elementOrCss;
17375
17206
  return css2.transform !== "none" || css2.perspective !== "none" || (css2.containerType ? css2.containerType !== "normal" : false) || !webkit && (css2.backdropFilter ? css2.backdropFilter !== "none" : false) || !webkit && (css2.filter ? css2.filter !== "none" : false) || ["transform", "perspective", "filter"].some((value) => (css2.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css2.contain || "").includes(value));
17376
17207
  }
17377
17208
  function getContainingBlock$1(element) {
17378
17209
  let currentNode = getParentNode$1(element);
17379
17210
  while (isHTMLElement$1(currentNode) && !isLastTraversableNode(currentNode)) {
17380
- if (isTopLayer(currentNode)) {
17381
- return null;
17382
- }
17383
17211
  if (isContainingBlock(currentNode)) {
17384
17212
  return currentNode;
17213
+ } else if (isTopLayer(currentNode)) {
17214
+ return null;
17385
17215
  }
17386
17216
  currentNode = getParentNode$1(currentNode);
17387
17217
  }
@@ -17439,10 +17269,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
17439
17269
  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
17440
17270
  const win = getWindow$1(scrollableAncestor);
17441
17271
  if (isBody) {
17442
- return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
17272
+ const frameElement = getFrameElement(win);
17273
+ return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
17443
17274
  }
17444
17275
  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
17445
17276
  }
17277
+ function getFrameElement(win) {
17278
+ return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
17279
+ }
17446
17280
  function contains$1(parent, child) {
17447
17281
  if (!parent || !child) {
17448
17282
  return false;
@@ -17715,7 +17549,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
17715
17549
  x: nextX,
17716
17550
  y: nextY,
17717
17551
  data,
17718
- reset: reset2
17552
+ reset
17719
17553
  } = await fn({
17720
17554
  x: x2,
17721
17555
  y: y2,
@@ -17739,18 +17573,18 @@ var __privateWrapper = (obj, member, setter, getter) => ({
17739
17573
  ...data
17740
17574
  }
17741
17575
  };
17742
- if (reset2 && resetCount <= 50) {
17576
+ if (reset && resetCount <= 50) {
17743
17577
  resetCount++;
17744
- if (typeof reset2 === "object") {
17745
- if (reset2.placement) {
17746
- statefulPlacement = reset2.placement;
17578
+ if (typeof reset === "object") {
17579
+ if (reset.placement) {
17580
+ statefulPlacement = reset.placement;
17747
17581
  }
17748
- if (reset2.rects) {
17749
- rects = reset2.rects === true ? await platform2.getElementRects({
17582
+ if (reset.rects) {
17583
+ rects = reset.rects === true ? await platform2.getElementRects({
17750
17584
  reference: reference2,
17751
17585
  floating,
17752
17586
  strategy
17753
- }) : reset2.rects;
17587
+ }) : reset.rects;
17754
17588
  }
17755
17589
  ({
17756
17590
  x: x2,
@@ -18276,10 +18110,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
18276
18110
  crossAxis: 0,
18277
18111
  alignmentAxis: null
18278
18112
  } : {
18279
- mainAxis: 0,
18280
- crossAxis: 0,
18281
- alignmentAxis: null,
18282
- ...rawValue
18113
+ mainAxis: rawValue.mainAxis || 0,
18114
+ crossAxis: rawValue.crossAxis || 0,
18115
+ alignmentAxis: rawValue.alignmentAxis
18283
18116
  };
18284
18117
  if (alignment && typeof alignmentAxis === "number") {
18285
18118
  crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
@@ -18384,7 +18217,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
18384
18217
  ...limitedCoords,
18385
18218
  data: {
18386
18219
  x: limitedCoords.x - x2,
18387
- y: limitedCoords.y - y2
18220
+ y: limitedCoords.y - y2,
18221
+ enabled: {
18222
+ [mainAxis]: checkMainAxis,
18223
+ [crossAxis]: checkCrossAxis
18224
+ }
18388
18225
  }
18389
18226
  };
18390
18227
  }
@@ -18463,6 +18300,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
18463
18300
  name: "size",
18464
18301
  options,
18465
18302
  async fn(state) {
18303
+ var _state$middlewareData, _state$middlewareData2;
18466
18304
  const {
18467
18305
  placement,
18468
18306
  rects,
@@ -18498,10 +18336,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
18498
18336
  const noShift = !state.middlewareData.shift;
18499
18337
  let availableHeight = overflowAvailableHeight;
18500
18338
  let availableWidth = overflowAvailableWidth;
18501
- if (isYAxis) {
18502
- availableWidth = alignment || noShift ? min$2(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;
18503
- } else {
18504
- availableHeight = alignment || noShift ? min$2(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;
18339
+ if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {
18340
+ availableWidth = maximumClippingWidth;
18341
+ }
18342
+ if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {
18343
+ availableHeight = maximumClippingHeight;
18505
18344
  }
18506
18345
  if (noShift && !alignment) {
18507
18346
  const xMin = max$2(overflow.left, 0);
@@ -18624,7 +18463,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
18624
18463
  const win = getWindow$1(domElement);
18625
18464
  const offsetWin = offsetParent && isElement$3(offsetParent) ? getWindow$1(offsetParent) : offsetParent;
18626
18465
  let currentWin = win;
18627
- let currentIFrame = currentWin.frameElement;
18466
+ let currentIFrame = getFrameElement(currentWin);
18628
18467
  while (currentIFrame && offsetParent && offsetWin !== currentWin) {
18629
18468
  const iframeScale = getScale(currentIFrame);
18630
18469
  const iframeRect = currentIFrame.getBoundingClientRect();
@@ -18638,7 +18477,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
18638
18477
  x2 += left2;
18639
18478
  y2 += top2;
18640
18479
  currentWin = getWindow$1(currentIFrame);
18641
- currentIFrame = currentWin.frameElement;
18480
+ currentIFrame = getFrameElement(currentWin);
18642
18481
  }
18643
18482
  }
18644
18483
  return rectToClientRect$1({
@@ -18689,8 +18528,12 @@ var __privateWrapper = (obj, member, setter, getter) => ({
18689
18528
  function getClientRects(element) {
18690
18529
  return Array.from(element.getClientRects());
18691
18530
  }
18692
- function getWindowScrollBarX$1(element) {
18693
- return getBoundingClientRect$1(getDocumentElement$1(element)).left + getNodeScroll$1(element).scrollLeft;
18531
+ function getWindowScrollBarX$1(element, rect) {
18532
+ const leftScroll = getNodeScroll$1(element).scrollLeft;
18533
+ if (!rect) {
18534
+ return getBoundingClientRect$1(getDocumentElement$1(element)).left + leftScroll;
18535
+ }
18536
+ return rect.left + leftScroll;
18694
18537
  }
18695
18538
  function getDocumentRect$1(element) {
18696
18539
  const html = getDocumentElement$1(element);
@@ -18858,8 +18701,15 @@ var __privateWrapper = (obj, member, setter, getter) => ({
18858
18701
  offsets.x = getWindowScrollBarX$1(documentElement);
18859
18702
  }
18860
18703
  }
18861
- const x2 = rect.left + scroll.scrollLeft - offsets.x;
18862
- const y2 = rect.top + scroll.scrollTop - offsets.y;
18704
+ let htmlX = 0;
18705
+ let htmlY = 0;
18706
+ if (documentElement && !isOffsetParentAnElement && !isFixed) {
18707
+ const htmlRect = documentElement.getBoundingClientRect();
18708
+ htmlY = htmlRect.top + scroll.scrollTop;
18709
+ htmlX = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX$1(documentElement, htmlRect);
18710
+ }
18711
+ const x2 = rect.left + scroll.scrollLeft - offsets.x - htmlX;
18712
+ const y2 = rect.top + scroll.scrollTop - offsets.y - htmlY;
18863
18713
  return {
18864
18714
  x: x2,
18865
18715
  y: y2,
@@ -18877,7 +18727,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
18877
18727
  if (polyfill) {
18878
18728
  return polyfill(element);
18879
18729
  }
18880
- return element.offsetParent;
18730
+ let rawOffsetParent = element.offsetParent;
18731
+ if (getDocumentElement$1(element) === rawOffsetParent) {
18732
+ rawOffsetParent = rawOffsetParent.ownerDocument.body;
18733
+ }
18734
+ return rawOffsetParent;
18881
18735
  }
18882
18736
  function getOffsetParent$1(element, polyfill) {
18883
18737
  const win = getWindow$1(element);
@@ -19211,6 +19065,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
19211
19065
  const hasWhileElementsMounted = whileElementsMounted != null;
19212
19066
  const whileElementsMountedRef = useLatestRef$1(whileElementsMounted);
19213
19067
  const platformRef = useLatestRef$1(platform2);
19068
+ const openRef = useLatestRef$1(open2);
19214
19069
  const update = React__namespace.useCallback(() => {
19215
19070
  if (!referenceRef.current || !floatingRef.current) {
19216
19071
  return;
@@ -19226,7 +19081,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
19226
19081
  computePosition(referenceRef.current, floatingRef.current, config2).then((data2) => {
19227
19082
  const fullData = {
19228
19083
  ...data2,
19229
- isPositioned: true
19084
+ isPositioned: openRef.current !== false
19230
19085
  };
19231
19086
  if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
19232
19087
  dataRef.current = fullData;
@@ -19235,7 +19090,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
19235
19090
  });
19236
19091
  }
19237
19092
  });
19238
- }, [latestMiddleware, placement, strategy, platformRef]);
19093
+ }, [latestMiddleware, placement, strategy, platformRef, openRef]);
19239
19094
  index$3(() => {
19240
19095
  if (open2 === false && dataRef.current.isPositioned) {
19241
19096
  dataRef.current.isPositioned = false;
@@ -19404,6 +19259,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
19404
19259
  }
19405
19260
  return allChildren;
19406
19261
  }
19262
+ const FOCUSABLE_ATTRIBUTE = "data-floating-ui-focusable";
19407
19263
  function isButtonTarget(event) {
19408
19264
  return isHTMLElement$1(event.target) && event.target.tagName === "BUTTON";
19409
19265
  }
@@ -19550,11 +19406,15 @@ var __privateWrapper = (obj, member, setter, getter) => ({
19550
19406
  escapeKey: escapeKeyCapture,
19551
19407
  outsidePress: outsidePressCapture
19552
19408
  } = normalizeProp(capture);
19409
+ const isComposingRef = React__namespace.useRef(false);
19553
19410
  const closeOnEscapeKeyDown = useEffectEvent((event) => {
19554
19411
  var _dataRef$current$floa;
19555
19412
  if (!open2 || !enabled || !escapeKey || event.key !== "Escape") {
19556
19413
  return;
19557
19414
  }
19415
+ if (isComposingRef.current) {
19416
+ return;
19417
+ }
19558
19418
  const nodeId = (_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.nodeId;
19559
19419
  const children = tree ? getChildren$2(tree.nodesRef.current, nodeId) : [];
19560
19420
  if (!escapeKeyBubbles) {
@@ -19666,11 +19526,28 @@ var __privateWrapper = (obj, member, setter, getter) => ({
19666
19526
  }
19667
19527
  dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
19668
19528
  dataRef.current.__outsidePressBubbles = outsidePressBubbles;
19529
+ let compositionTimeout = -1;
19669
19530
  function onScroll(event) {
19670
19531
  onOpenChange(false, event, "ancestor-scroll");
19671
19532
  }
19533
+ function handleCompositionStart() {
19534
+ window.clearTimeout(compositionTimeout);
19535
+ isComposingRef.current = true;
19536
+ }
19537
+ function handleCompositionEnd() {
19538
+ compositionTimeout = window.setTimeout(
19539
+ () => {
19540
+ isComposingRef.current = false;
19541
+ },
19542
+ isWebKit() ? 5 : 0
19543
+ );
19544
+ }
19672
19545
  const doc = getDocument(elements.floating);
19673
- escapeKey && doc.addEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
19546
+ if (escapeKey) {
19547
+ doc.addEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
19548
+ doc.addEventListener("compositionstart", handleCompositionStart);
19549
+ doc.addEventListener("compositionend", handleCompositionEnd);
19550
+ }
19674
19551
  outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
19675
19552
  let ancestors = [];
19676
19553
  if (ancestorScroll) {
@@ -19694,11 +19571,16 @@ var __privateWrapper = (obj, member, setter, getter) => ({
19694
19571
  });
19695
19572
  });
19696
19573
  return () => {
19697
- escapeKey && doc.removeEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
19574
+ if (escapeKey) {
19575
+ doc.removeEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
19576
+ doc.removeEventListener("compositionstart", handleCompositionStart);
19577
+ doc.removeEventListener("compositionend", handleCompositionEnd);
19578
+ }
19698
19579
  outsidePress && doc.removeEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
19699
19580
  ancestors.forEach((ancestor) => {
19700
19581
  ancestor.removeEventListener("scroll", onScroll);
19701
19582
  });
19583
+ window.clearTimeout(compositionTimeout);
19702
19584
  };
19703
19585
  }, [dataRef, elements, escapeKey, outsidePress, outsidePressEvent, open2, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, escapeKeyCapture, closeOnEscapeKeyDownCapture, closeOnPressOutside, outsidePressCapture, closeOnPressOutsideCapture]);
19704
19586
  React__namespace.useEffect(() => {
@@ -19869,7 +19751,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
19869
19751
  }
19870
19752
  return {
19871
19753
  ...elementKey === "floating" && {
19872
- tabIndex: -1
19754
+ tabIndex: -1,
19755
+ [FOCUSABLE_ATTRIBUTE]: ""
19873
19756
  },
19874
19757
  ...domUserProps,
19875
19758
  ...propsList.map((value) => {
@@ -24655,7 +24538,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
24655
24538
  var func = isArray2(collection) ? arraySampleSize : baseSampleSize;
24656
24539
  return func(collection, n2);
24657
24540
  }
24658
- function shuffle2(collection) {
24541
+ function shuffle(collection) {
24659
24542
  var func = isArray2(collection) ? arrayShuffle : baseShuffle;
24660
24543
  return func(collection);
24661
24544
  }
@@ -25433,7 +25316,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
25433
25316
  number2 = toNumber2(number2);
25434
25317
  return baseInRange(number2, start2, end2);
25435
25318
  }
25436
- function random2(lower, upper, floating) {
25319
+ function random(lower, upper, floating) {
25437
25320
  if (floating && typeof floating != "boolean" && isIterateeCall(lower, upper, floating)) {
25438
25321
  upper = floating = undefined$1;
25439
25322
  }
@@ -26029,7 +25912,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
26029
25912
  lodash2.sampleSize = sampleSize;
26030
25913
  lodash2.set = set2;
26031
25914
  lodash2.setWith = setWith;
26032
- lodash2.shuffle = shuffle2;
25915
+ lodash2.shuffle = shuffle;
26033
25916
  lodash2.slice = slice;
26034
25917
  lodash2.sortBy = sortBy;
26035
25918
  lodash2.sortedUniq = sortedUniq;
@@ -26187,7 +26070,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
26187
26070
  lodash2.padEnd = padEnd;
26188
26071
  lodash2.padStart = padStart;
26189
26072
  lodash2.parseInt = parseInt2;
26190
- lodash2.random = random2;
26073
+ lodash2.random = random;
26191
26074
  lodash2.reduce = reduce2;
26192
26075
  lodash2.reduceRight = reduceRight;
26193
26076
  lodash2.repeat = repeat;
@@ -26409,19 +26292,6 @@ var __privateWrapper = (obj, member, setter, getter) => ({
26409
26292
  }
26410
26293
  }).call(commonjsGlobal$1);
26411
26294
  })(lodash$2, lodash$2.exports);
26412
- let nanoid = (size2 = 21) => crypto.getRandomValues(new Uint8Array(size2)).reduce((id, byte) => {
26413
- byte &= 63;
26414
- if (byte < 36) {
26415
- id += byte.toString(36);
26416
- } else if (byte < 62) {
26417
- id += (byte - 26).toString(36).toUpperCase();
26418
- } else if (byte > 62) {
26419
- id += "-";
26420
- } else {
26421
- id += "_";
26422
- }
26423
- return id;
26424
- }, "");
26425
26295
  styled__default.default.span`
26426
26296
  display: flex;
26427
26297
  flex-direction: column;
@@ -34729,8 +34599,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
34729
34599
  if (t2[0] & 1)
34730
34600
  throw t2[1];
34731
34601
  return t2[1];
34732
- }, trys: [], ops: [] }, f2, y2, t2, g2;
34733
- return g2 = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g2[Symbol.iterator] = function() {
34602
+ }, trys: [], ops: [] }, f2, y2, t2, g2 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
34603
+ return g2.next = verb(0), g2["throw"] = verb(1), g2["return"] = verb(2), typeof Symbol === "function" && (g2[Symbol.iterator] = function() {
34734
34604
  return this;
34735
34605
  }), g2;
34736
34606
  function verb(n2) {
@@ -34858,7 +34728,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
34858
34728
  if (!Symbol.asyncIterator)
34859
34729
  throw new TypeError("Symbol.asyncIterator is not defined.");
34860
34730
  var g2 = generator.apply(thisArg, _arguments || []), i2, q2 = [];
34861
- return i2 = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i2[Symbol.asyncIterator] = function() {
34731
+ return i2 = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i2[Symbol.asyncIterator] = function() {
34862
34732
  return this;
34863
34733
  }, i2;
34864
34734
  function awaitReturn(f2) {
@@ -35865,7 +35735,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
35865
35735
  selectedItem: newSelectedItem
35866
35736
  });
35867
35737
  }, [dispatch]);
35868
- var reset2 = React.useCallback(function() {
35738
+ var reset = React.useCallback(function() {
35869
35739
  dispatch({
35870
35740
  type: FunctionReset$2
35871
35741
  });
@@ -35994,7 +35864,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
35994
35864
  closeMenu,
35995
35865
  setHighlightedIndex,
35996
35866
  selectItem,
35997
- reset: reset2,
35867
+ reset,
35998
35868
  setInputValue,
35999
35869
  highlightedIndex,
36000
35870
  isOpen,
@@ -36553,7 +36423,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
36553
36423
  inputValue: newInputValue
36554
36424
  });
36555
36425
  }, [dispatch]);
36556
- var reset2 = React.useCallback(function() {
36426
+ var reset = React.useCallback(function() {
36557
36427
  dispatch({
36558
36428
  type: FunctionReset$1
36559
36429
  });
@@ -36570,7 +36440,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
36570
36440
  setHighlightedIndex,
36571
36441
  setInputValue,
36572
36442
  selectItem,
36573
- reset: reset2,
36443
+ reset,
36574
36444
  highlightedIndex,
36575
36445
  isOpen,
36576
36446
  selectedItem,
@@ -41274,12 +41144,12 @@ var __privateWrapper = (obj, member, setter, getter) => ({
41274
41144
  window.removeEventListener("testPassiveEventSupport", noop2, options);
41275
41145
  return passive2;
41276
41146
  };
41277
- function autoInc(seed2) {
41278
- if (seed2 === void 0) {
41279
- seed2 = 0;
41147
+ function autoInc(seed) {
41148
+ if (seed === void 0) {
41149
+ seed = 0;
41280
41150
  }
41281
41151
  return function() {
41282
- return ++seed2;
41152
+ return ++seed;
41283
41153
  };
41284
41154
  }
41285
41155
  var uid = autoInc();
@@ -44233,6 +44103,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
44233
44103
  var _default = function(file, acceptedFiles) {
44234
44104
  if (file && acceptedFiles) {
44235
44105
  var acceptedFilesArray = Array.isArray(acceptedFiles) ? acceptedFiles : acceptedFiles.split(",");
44106
+ if (acceptedFilesArray.length === 0) {
44107
+ return true;
44108
+ }
44236
44109
  var fileName = file.name || "";
44237
44110
  var mimeType = (file.type || "").toLowerCase();
44238
44111
  var baseMimeType = mimeType.replace(/\/.*$/, "");
@@ -45653,30 +45526,30 @@ var __privateWrapper = (obj, member, setter, getter) => ({
45653
45526
  step(stepSkip * -1);
45654
45527
  }
45655
45528
  };
45656
- const handleOnChange = React.useCallback(
45657
- (v2, e3) => {
45658
- const parsed = props.integerOnly ? parseInt(v2) : parseFloat(v2);
45659
- if (value === void 0) {
45660
- setInput(v2);
45661
- onChange2 === null || onChange2 === void 0 ? void 0 : onChange2(parsed, e3);
45662
- return;
45663
- }
45664
- if (v2.endsWith(".")) {
45665
- setInput(v2);
45666
- return;
45667
- }
45668
- if (v2.includes(".") && v2.endsWith("0")) {
45669
- setInput(v2);
45670
- return;
45671
- }
45672
- if (v2 === "-") {
45673
- setInput(v2);
45674
- return;
45675
- }
45529
+ const handleOnChange = React.useCallback((v2, e3) => {
45530
+ const parsed = props.integerOnly ? parseInt(v2) : parseFloat(v2);
45531
+ if (value === void 0) {
45532
+ setInput(v2);
45676
45533
  onChange2 === null || onChange2 === void 0 ? void 0 : onChange2(parsed, e3);
45677
- },
45678
- [props.integerOnly, value, onChange2]
45679
- );
45534
+ return;
45535
+ }
45536
+ if (v2.endsWith(".")) {
45537
+ setInput(v2);
45538
+ return;
45539
+ }
45540
+ if (v2.includes(".") && v2.endsWith("0")) {
45541
+ setInput(v2);
45542
+ return;
45543
+ }
45544
+ if (v2 === "-") {
45545
+ setInput(v2);
45546
+ return;
45547
+ }
45548
+ if (input.endsWith(".")) {
45549
+ setInput(v2);
45550
+ }
45551
+ onChange2 === null || onChange2 === void 0 ? void 0 : onChange2(parsed, e3);
45552
+ }, [props.integerOnly, value, onChange2, input]);
45680
45553
  React.useEffect(() => {
45681
45554
  setInput(getInitialValue(value, initialValue));
45682
45555
  }, [value]);
@@ -49527,7 +49400,7 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
49527
49400
  key: "render",
49528
49401
  value: function render2() {
49529
49402
  var _props = this.props, children = _props.children, className = _props.className, disableHeight = _props.disableHeight, disableWidth = _props.disableWidth, style = _props.style;
49530
- var _state = this.state, height = _state.height, width = _state.width;
49403
+ var _state2 = this.state, height = _state2.height, width = _state2.width;
49531
49404
  var outerStyle = { overflow: "visible" };
49532
49405
  var childParams = {};
49533
49406
  var bailoutOnChildren = false;
@@ -52837,14 +52710,14 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
52837
52710
  resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();
52838
52711
  resetConnection = void 0;
52839
52712
  };
52840
- var reset2 = function() {
52713
+ var reset = function() {
52841
52714
  cancelReset();
52842
52715
  connection = subject = void 0;
52843
52716
  hasCompleted = hasErrored = false;
52844
52717
  };
52845
52718
  var resetAndUnsubscribe = function() {
52846
52719
  var conn = connection;
52847
- reset2();
52720
+ reset();
52848
52721
  conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
52849
52722
  };
52850
52723
  return operate(function(source, subscriber) {
@@ -52868,13 +52741,13 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
52868
52741
  error: function(err2) {
52869
52742
  hasErrored = true;
52870
52743
  cancelReset();
52871
- resetConnection = handleReset(reset2, resetOnError, err2);
52744
+ resetConnection = handleReset(reset, resetOnError, err2);
52872
52745
  dest.error(err2);
52873
52746
  },
52874
52747
  complete: function() {
52875
52748
  hasCompleted = true;
52876
52749
  cancelReset();
52877
- resetConnection = handleReset(reset2, resetOnComplete);
52750
+ resetConnection = handleReset(reset, resetOnComplete);
52878
52751
  dest.complete();
52879
52752
  }
52880
52753
  });
@@ -52883,13 +52756,13 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
52883
52756
  })(wrapperSource);
52884
52757
  };
52885
52758
  }
52886
- function handleReset(reset2, on) {
52759
+ function handleReset(reset, on) {
52887
52760
  var args = [];
52888
52761
  for (var _i = 2; _i < arguments.length; _i++) {
52889
52762
  args[_i - 2] = arguments[_i];
52890
52763
  }
52891
52764
  if (on === true) {
52892
- reset2();
52765
+ reset();
52893
52766
  return;
52894
52767
  }
52895
52768
  if (on === false) {
@@ -52898,7 +52771,7 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
52898
52771
  var onSubscriber = new SafeSubscriber({
52899
52772
  next: function() {
52900
52773
  onSubscriber.unsubscribe();
52901
- reset2();
52774
+ reset();
52902
52775
  }
52903
52776
  });
52904
52777
  return innerFrom(on.apply(void 0, __spreadArray([], __read(args)))).subscribe(onSubscriber);
@@ -54397,7 +54270,7 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
54397
54270
  return ConditionOperator2;
54398
54271
  })(ConditionOperator || {});
54399
54272
  function isVariable(variable) {
54400
- return variable && Object.keys(variable).includes("uid") && Object.keys(variable).includes("__typename") && variable.__typename.includes("Variable");
54273
+ return variable && typeof variable == "object" && variable.hasOwnProperty("uid") && variable.hasOwnProperty("__typename") && variable.__typename.includes("Variable");
54401
54274
  }
54402
54275
  function isUrlVariable(variable) {
54403
54276
  return isVariable(variable) && variable.__typename === "UrlVariable";
@@ -55083,13 +54956,85 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
55083
54956
  return baseClone$1(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG$1);
55084
54957
  }
55085
54958
  var cloneDeep_1 = cloneDeep;
54959
+ class GlobalStore {
54960
+ constructor() {
54961
+ __privateAdd(this, _notify);
54962
+ __privateAdd(this, _state, void 0);
54963
+ __privateAdd(this, _locks, void 0);
54964
+ __privateAdd(this, _subscribers, void 0);
54965
+ __privateSet(this, _state, {});
54966
+ __privateSet(this, _locks, {});
54967
+ __privateSet(this, _subscribers, {});
54968
+ }
54969
+ clear() {
54970
+ __privateSet(this, _state, {});
54971
+ __privateSet(this, _locks, {});
54972
+ __privateSet(this, _subscribers, {});
54973
+ }
54974
+ async getValue(key) {
54975
+ if (__privateGet(this, _locks)[key]) {
54976
+ return __privateGet(this, _locks)[key];
54977
+ }
54978
+ return __privateGet(this, _state)[key];
54979
+ }
54980
+ getValueSync(key) {
54981
+ return __privateGet(this, _state)[key];
54982
+ }
54983
+ setValue(key, value) {
54984
+ __privateMethod(this, _notify, notify_fn).call(this, key, value);
54985
+ __privateGet(this, _state)[key] = value;
54986
+ }
54987
+ async replaceValue(key, fn) {
54988
+ if (__privateGet(this, _locks)[key]) {
54989
+ return __privateGet(this, _locks)[key];
54990
+ }
54991
+ let unlock;
54992
+ let unlockError;
54993
+ const lockPromise = new Promise((resolve, reject) => {
54994
+ unlock = resolve;
54995
+ unlockError = reject;
54996
+ });
54997
+ __privateGet(this, _locks)[key] = lockPromise;
54998
+ let result;
54999
+ try {
55000
+ result = await fn();
55001
+ __privateGet(this, _state)[key] = result;
55002
+ __privateMethod(this, _notify, notify_fn).call(this, key, result);
55003
+ unlock(result);
55004
+ this.setValue(key, result);
55005
+ } catch (e3) {
55006
+ unlockError(e3);
55007
+ } finally {
55008
+ delete __privateGet(this, _locks)[key];
55009
+ }
55010
+ return lockPromise;
55011
+ }
55012
+ subscribe(key, callback) {
55013
+ if (!__privateGet(this, _subscribers)[key]) {
55014
+ __privateGet(this, _subscribers)[key] = [];
55015
+ }
55016
+ __privateGet(this, _subscribers)[key].push(callback);
55017
+ return () => {
55018
+ __privateGet(this, _subscribers)[key] = __privateGet(this, _subscribers)[key].filter((cb) => cb !== callback);
55019
+ };
55020
+ }
55021
+ }
55022
+ _state = new WeakMap();
55023
+ _locks = new WeakMap();
55024
+ _subscribers = new WeakMap();
55025
+ _notify = new WeakSet();
55026
+ notify_fn = function(key, value) {
55027
+ if (__privateGet(this, _subscribers)[key]) {
55028
+ __privateGet(this, _subscribers)[key].forEach((cb) => cb(value));
55029
+ }
55030
+ };
55031
+ const store = new GlobalStore();
55086
55032
  class RequestExtrasSerializable {
55087
55033
  constructor(extras) {
55088
55034
  __publicField(this, "extras");
55089
55035
  this.extras = extras;
55090
55036
  }
55091
55037
  toSerializable() {
55092
- var _a;
55093
55038
  if (!this.extras) {
55094
55039
  return null;
55095
55040
  }
@@ -55097,9 +55042,9 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
55097
55042
  return this.extras;
55098
55043
  }
55099
55044
  const serializable = cloneDeep_1(this.extras);
55100
- if ((_a = serializable.options) == null ? void 0 : _a.headers) {
55101
- const headers = new Headers(serializable.options.headers);
55102
- serializable.options.headers = Object.fromEntries(headers.entries());
55045
+ if (serializable == null ? void 0 : serializable.headers) {
55046
+ const headers = new Headers(serializable.headers);
55047
+ serializable.headers = Object.fromEntries(headers.entries());
55103
55048
  }
55104
55049
  return serializable;
55105
55050
  }
@@ -55113,8 +55058,8 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
55113
55058
  }
55114
55059
  async function request(url, options, extras) {
55115
55060
  var _a, _b;
55116
- const sessionToken = typeof extras === "string" ? extras : extras == null ? void 0 : extras.sessionToken;
55117
- const mergedOptions = extras && typeof extras === "object" ? { ...options, ...extras.options } : options;
55061
+ const sessionToken = await store.getValue("sessionToken");
55062
+ const mergedOptions = extras ? { ...options, ...extras } : options;
55118
55063
  const { headers, ...other } = mergedOptions;
55119
55064
  const headersInterface = new Headers(headers);
55120
55065
  if (!headersInterface.has("Accept")) {
@@ -55128,18 +55073,35 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
55128
55073
  }
55129
55074
  const baseUrl = (_b = (_a = window.dara) == null ? void 0 : _a.base_url) != null ? _b : "";
55130
55075
  const urlString = url instanceof URL ? url.pathname + url.search : url;
55131
- return fetch(baseUrl + urlString, {
55076
+ const response = await fetch(baseUrl + urlString, {
55132
55077
  headers: headersInterface,
55133
55078
  ...other
55134
55079
  });
55135
- }
55136
- const authCtx = React__namespace.createContext({ setToken: noop_1, token: "" });
55137
- function useAuthCtx() {
55138
- return React__namespace.useContext(authCtx);
55139
- }
55140
- function useSessionToken() {
55141
- const { token } = React__namespace.useContext(authCtx);
55142
- return token;
55080
+ if (response.status === 401 || response.status === 403) {
55081
+ try {
55082
+ const refreshedToken = await store.replaceValue("sessionToken", async () => {
55083
+ const refreshResponse = await fetch(`${baseUrl}/api/auth/refresh-token`, {
55084
+ headers: headersInterface,
55085
+ ...other,
55086
+ method: "POST"
55087
+ });
55088
+ if (refreshResponse.ok) {
55089
+ const { token } = await refreshResponse.json();
55090
+ return token;
55091
+ }
55092
+ await validateResponse(refreshResponse, "Request auth error, failed to refresh the session token");
55093
+ });
55094
+ headersInterface.set("Authorization", `Bearer ${refreshedToken}`);
55095
+ return fetch(baseUrl + urlString, {
55096
+ headers: headersInterface,
55097
+ ...other
55098
+ });
55099
+ } catch (e3) {
55100
+ console.error("Failed to refresh token", e3);
55101
+ return response;
55102
+ }
55103
+ }
55104
+ return response;
55143
55105
  }
55144
55106
  const directionCtx = React.createContext({ direction: "row" });
55145
55107
  const importersCtx = React.createContext({});
@@ -56061,14 +56023,10 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
56061
56023
  }
56062
56024
  const requestExtrasCtx = React.createContext({ options: {} });
56063
56025
  function useRequestExtras() {
56064
- const sessionToken = useSessionToken();
56065
56026
  const { options } = React.useContext(requestExtrasCtx);
56066
56027
  const extras = React.useMemo(() => {
56067
- return {
56068
- options,
56069
- sessionToken
56070
- };
56071
- }, [useDeepCompare(options), sessionToken]);
56028
+ return options;
56029
+ }, [useDeepCompare(options)]);
56072
56030
  return extras;
56073
56031
  }
56074
56032
  function RequestExtrasProvider({
@@ -56195,23 +56153,17 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
56195
56153
  { refetchOnWindowFocus: false }
56196
56154
  );
56197
56155
  }
56198
- async function revokeSession(token) {
56199
- if (token) {
56200
- try {
56201
- const response = await request(
56202
- "/api/auth/revoke-session",
56203
- {
56204
- method: HTTP_METHOD.POST
56205
- },
56206
- token
56207
- );
56208
- if (response.ok) {
56209
- const responseData = await response.json();
56210
- return responseData;
56211
- }
56212
- } catch (e3) {
56213
- console.error("Failed to revoke session", e3);
56156
+ async function revokeSession() {
56157
+ try {
56158
+ const response = await request("/api/auth/revoke-session", {
56159
+ method: HTTP_METHOD.POST
56160
+ });
56161
+ if (response.ok) {
56162
+ const responseData = await response.json();
56163
+ return responseData;
56214
56164
  }
56165
+ } catch (e3) {
56166
+ console.error("Failed to revoke session", e3);
56215
56167
  }
56216
56168
  }
56217
56169
  async function handleAuthErrors(res, toLogin = false, ignoreErrors = null) {
@@ -56240,7 +56192,7 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
56240
56192
  refetchOnWindowFocus: false
56241
56193
  });
56242
56194
  }
56243
- async function getSessionToken(body = {}) {
56195
+ async function requestSessionToken(body = {}) {
56244
56196
  const res = await request("/api/auth/session", {
56245
56197
  body: JSON.stringify(body),
56246
56198
  method: HTTP_METHOD.POST
@@ -56255,14 +56207,10 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
56255
56207
  localStorage.setItem(getTokenKey(), token);
56256
56208
  return token;
56257
56209
  }
56258
- async function verifySessionToken(token) {
56259
- const res = await request(
56260
- "/api/auth/verify-session",
56261
- {
56262
- method: HTTP_METHOD.POST
56263
- },
56264
- token
56265
- );
56210
+ async function verifySessionToken() {
56211
+ const res = await request("/api/auth/verify-session", {
56212
+ method: HTTP_METHOD.POST
56213
+ });
56266
56214
  return res.ok;
56267
56215
  }
56268
56216
  function isPlaceholder(value) {
@@ -56284,18 +56232,18 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
56284
56232
  }
56285
56233
  return Object.entries(obj);
56286
56234
  }
56287
- function denormalize(obj, lookup2) {
56235
+ function denormalize(obj, lookup) {
56288
56236
  if (!obj) {
56289
56237
  return obj;
56290
56238
  }
56291
56239
  if (isPlaceholder(obj)) {
56292
- const referrable = lookup2[obj.__ref];
56293
- return denormalize(referrable, lookup2);
56240
+ const referrable = lookup[obj.__ref];
56241
+ return denormalize(referrable, lookup);
56294
56242
  }
56295
56243
  const output = Array.isArray(obj) ? [] : {};
56296
56244
  for (const [key, val] of getEntries(obj)) {
56297
56245
  if (val !== null && typeof val === "object") {
56298
- output[key] = denormalize(val, lookup2);
56246
+ output[key] = denormalize(val, lookup);
56299
56247
  } else {
56300
56248
  output[key] = val;
56301
56249
  }
@@ -56304,7 +56252,7 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
56304
56252
  }
56305
56253
  function normalizeResolvedDerivedVariable(resolved, def) {
56306
56254
  const normalizedValues = [];
56307
- let lookup2 = {};
56255
+ let lookup = {};
56308
56256
  for (const [key, val] of resolved.values.entries()) {
56309
56257
  if (isResolvedDerivedVariable(val) || isResolvedDerivedDataVariable(val)) {
56310
56258
  const { data: nestedNormalized, lookup: nestedLookup } = normalizeResolvedDerivedVariable(
@@ -56312,14 +56260,14 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
56312
56260
  def.variables[key]
56313
56261
  );
56314
56262
  normalizedValues.push(nestedNormalized);
56315
- lookup2 = {
56316
- ...lookup2,
56263
+ lookup = {
56264
+ ...lookup,
56317
56265
  ...nestedLookup
56318
56266
  };
56319
56267
  } else {
56320
56268
  const varDef = def.variables[key];
56321
56269
  const identifier = getIdentifier(varDef);
56322
- lookup2[identifier] = val;
56270
+ lookup[identifier] = val;
56323
56271
  normalizedValues.push({ __ref: identifier });
56324
56272
  }
56325
56273
  }
@@ -56328,12 +56276,12 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
56328
56276
  ...resolved,
56329
56277
  values: normalizedValues
56330
56278
  },
56331
- lookup: lookup2
56279
+ lookup
56332
56280
  };
56333
56281
  }
56334
56282
  function normalizeRequest(values, kwargsDefinition) {
56335
56283
  const data = Array.isArray(values) ? [] : {};
56336
- let lookup2 = {};
56284
+ let lookup = {};
56337
56285
  for (const [key, val] of getEntries(values)) {
56338
56286
  const kwargDef = kwargsDefinition[key];
56339
56287
  if (!kwargDef) {
@@ -56341,13 +56289,13 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
56341
56289
  } else if (isDerivedVariable(kwargDef) || isDerivedDataVariable(kwargDef)) {
56342
56290
  const { data: nestedData, lookup: nestedLookup } = normalizeResolvedDerivedVariable(val, kwargDef);
56343
56291
  data[key] = nestedData;
56344
- lookup2 = {
56345
- ...lookup2,
56292
+ lookup = {
56293
+ ...lookup,
56346
56294
  ...nestedLookup
56347
56295
  };
56348
56296
  } else if (kwargDef.constructor === Object) {
56349
56297
  const identifier = getIdentifier(kwargDef);
56350
- lookup2[identifier] = val === void 0 ? null : val;
56298
+ lookup[identifier] = val === void 0 ? null : val;
56351
56299
  data[key] = { __ref: identifier };
56352
56300
  } else {
56353
56301
  data[key] = val;
@@ -56355,7 +56303,7 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
56355
56303
  }
56356
56304
  return {
56357
56305
  data,
56358
- lookup: lookup2
56306
+ lookup
56359
56307
  };
56360
56308
  }
56361
56309
  function useActions() {
@@ -56405,8 +56353,8 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
56405
56353
  const res = await request(`/api/core/template/${template}`, { method: HTTP_METHOD.GET }, extras);
56406
56354
  await handleAuthErrors(res, true);
56407
56355
  await validateResponse(res, "Failed to fetch the template");
56408
- const { data: normalizedTemplate, lookup: lookup2 } = await res.json();
56409
- return denormalize(normalizedTemplate, lookup2);
56356
+ const { data: normalizedTemplate, lookup } = await res.json();
56357
+ return denormalize(normalizedTemplate, lookup);
56410
56358
  },
56411
56359
  queryKey: ["template", template],
56412
56360
  refetchOnWindowFocus: false,
@@ -57946,7 +57894,7 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
57946
57894
  value: variableValue
57947
57895
  };
57948
57896
  },
57949
- key: shortid.generate()
57897
+ key: nanoid()
57950
57898
  })
57951
57899
  );
57952
57900
  }
@@ -57975,7 +57923,7 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
57975
57923
  const dvResponse = get2(dvSelector);
57976
57924
  return dvResponse.value;
57977
57925
  },
57978
- key: shortid.generate()
57926
+ key: nanoid()
57979
57927
  })
57980
57928
  );
57981
57929
  }
@@ -58146,6 +58094,18 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
58146
58094
  }
58147
58095
  return resolver(getOrRegisterPlainVariable(variable, client, taskContext, extras));
58148
58096
  }
58097
+ function tokenSubscribe(cb) {
58098
+ return store.subscribe("sessionToken", cb);
58099
+ }
58100
+ function getSessionToken() {
58101
+ return store.getValueSync("sessionToken");
58102
+ }
58103
+ function setSessionToken(token) {
58104
+ store.setValue("sessionToken", token);
58105
+ }
58106
+ function useSessionToken() {
58107
+ return React__namespace.useSyncExternalStore(tokenSubscribe, getSessionToken);
58108
+ }
58149
58109
  const STORE_EXTRAS_MAP = /* @__PURE__ */ new Map();
58150
58110
  function BackendStoreSync({ children }) {
58151
58111
  const { client } = React__namespace.useContext(websocketCtx);
@@ -58203,55 +58163,44 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
58203
58163
  storeKey: "BackendStore"
58204
58164
  });
58205
58165
  }
58206
- function getSessionKey(extras, uid2) {
58207
- const sessionToken = typeof extras === "string" ? extras : extras.sessionToken;
58166
+ function getSessionKey(uid2) {
58208
58167
  if (isEmbedded()) {
58209
58168
  return `dara-session-${window.frameElement.dataset.daraPageId}-var-${uid2}`;
58210
58169
  }
58211
- return `dara-session-${sessionToken}-var-${uid2}`;
58170
+ return `dara-session-${getSessionToken()}-var-${uid2}`;
58212
58171
  }
58213
58172
  function BrowserStoreSync({ children }) {
58214
- const extras = useRequestExtras();
58215
- const getStoreValue = React__namespace.useCallback(
58216
- (itemKey) => {
58173
+ const getStoreValue = React__namespace.useCallback((itemKey) => {
58174
+ var _a;
58175
+ const key = getSessionKey(itemKey);
58176
+ return JSON.parse((_a = localStorage.getItem(key)) != null ? _a : "null");
58177
+ }, []);
58178
+ const syncStoreValues = React__namespace.useCallback(({ diff }) => {
58179
+ for (const [itemKey, value] of diff.entries()) {
58180
+ const key = getSessionKey(itemKey);
58181
+ localStorage.setItem(key, JSON.stringify(value));
58182
+ }
58183
+ }, []);
58184
+ const listenToStoreChanges = React__namespace.useCallback(({ updateItem }) => {
58185
+ const listener2 = (e3) => {
58217
58186
  var _a;
58218
- const key = getSessionKey(extras, itemKey);
58219
- return JSON.parse((_a = localStorage.getItem(key)) != null ? _a : "null");
58220
- },
58221
- [extras]
58222
- );
58223
- const syncStoreValues = React__namespace.useCallback(
58224
- ({ diff }) => {
58225
- for (const [itemKey, value] of diff.entries()) {
58226
- const key = getSessionKey(extras, itemKey);
58227
- localStorage.setItem(key, JSON.stringify(value));
58228
- }
58229
- },
58230
- [extras]
58231
- );
58232
- const listenToStoreChanges = React__namespace.useCallback(
58233
- ({ updateItem }) => {
58234
- const listener2 = (e3) => {
58235
- var _a;
58236
- if (e3.storageArea === localStorage) {
58237
- if (e3.key) {
58238
- const match2 = e3.key.match(/^dara-session-(.*)-var-(.*)$/);
58239
- if (match2) {
58240
- const [, sessionToken, uid2] = match2;
58241
- if (typeof extras === "string" && sessionToken === extras || typeof extras === "object" && extras.sessionToken === sessionToken) {
58242
- updateItem(uid2, JSON.parse((_a = e3.newValue) != null ? _a : "null"));
58243
- }
58187
+ if (e3.storageArea === localStorage) {
58188
+ if (e3.key) {
58189
+ const match2 = e3.key.match(/^dara-session-(.*)-var-(.*)$/);
58190
+ if (match2) {
58191
+ const [, sessionToken, uid2] = match2;
58192
+ if (sessionToken === getSessionToken()) {
58193
+ updateItem(uid2, JSON.parse((_a = e3.newValue) != null ? _a : "null"));
58244
58194
  }
58245
58195
  }
58246
58196
  }
58247
- };
58248
- window.addEventListener("storage", listener2);
58249
- return () => {
58250
- window.removeEventListener("storage", listener2);
58251
- };
58252
- },
58253
- [extras]
58254
- );
58197
+ }
58198
+ };
58199
+ window.addEventListener("storage", listener2);
58200
+ return () => {
58201
+ window.removeEventListener("storage", listener2);
58202
+ };
58203
+ }, []);
58255
58204
  return /* @__PURE__ */ React__namespace.createElement(RecoilSync_index_1, { listen: listenToStoreChanges, read: getStoreValue, storeKey: "BrowserStore", write: syncStoreValues }, children);
58256
58205
  }
58257
58206
  function localStorageEffect(variable, extrasSerializable, wsClient, taskContext) {
@@ -58611,7 +58560,7 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
58611
58560
  }
58612
58561
  return;
58613
58562
  }
58614
- const executionId = shortid.generate();
58563
+ const executionId = nanoid();
58615
58564
  const observable2 = actionCtx.wsClient.actionMessages$(executionId);
58616
58565
  return new Promise((resolve, reject) => {
58617
58566
  let activeTasks = 0;
@@ -59167,26 +59116,31 @@ Inferred class string: "${iconClasses}."`
59167
59116
  }).catch((err2) => {
59168
59117
  throw new Error(`Failed to import module ${props.component.py_module}`, err2);
59169
59118
  });
59170
- }, [props.component]);
59119
+ }, [props.component, importers]);
59171
59120
  return component;
59172
59121
  }
59173
59122
  function AuthWrapper(props) {
59174
- const [token, setToken] = React.useState(() => getToken());
59175
59123
  const { data: authComponents, isLoading } = useAuthComponents();
59176
- function onSetToken(newToken) {
59177
- const key = getTokenKey();
59178
- if (newToken) {
59179
- localStorage.setItem(key, newToken);
59180
- } else {
59181
- localStorage.removeItem(key);
59182
- }
59183
- setToken(newToken);
59124
+ const isMounted = React.useRef(false);
59125
+ if (!isMounted.current) {
59126
+ isMounted.current = true;
59127
+ store.setValue("sessionToken", getToken());
59184
59128
  }
59129
+ React.useEffect(() => {
59130
+ return store.subscribe("sessionToken", (newToken) => {
59131
+ const key = getTokenKey();
59132
+ if (newToken) {
59133
+ localStorage.setItem(key, newToken);
59134
+ } else {
59135
+ localStorage.removeItem(key);
59136
+ }
59137
+ });
59138
+ }, []);
59185
59139
  if (isLoading) {
59186
59140
  return /* @__PURE__ */ React__default.default.createElement(Center, null, /* @__PURE__ */ React__default.default.createElement(DefaultFallback, null));
59187
59141
  }
59188
59142
  const { login, logout, ...extraRoutes } = authComponents;
59189
- return /* @__PURE__ */ React__default.default.createElement(authCtx.Provider, { value: { setToken: onSetToken, token } }, /* @__PURE__ */ React__default.default.createElement(Switch$1, null, /* @__PURE__ */ React__default.default.createElement(Route, { path: "/login" }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component: login })), /* @__PURE__ */ React__default.default.createElement(Route, { path: "/logout" }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component: logout })), Object.entries(extraRoutes).map(([path, component]) => /* @__PURE__ */ React__default.default.createElement(Route, { key: path, path: `/${path}` }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component }))), /* @__PURE__ */ React__default.default.createElement(Route, { component: ErrorPage, path: "/error" }), /* @__PURE__ */ React__default.default.createElement(Route, { path: "/", render: () => /* @__PURE__ */ React__default.default.createElement(PrivateRoute, null, props.children) })));
59143
+ return /* @__PURE__ */ React__default.default.createElement(Switch$1, null, /* @__PURE__ */ React__default.default.createElement(Route, { path: "/login" }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component: login })), /* @__PURE__ */ React__default.default.createElement(Route, { path: "/logout" }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component: logout })), Object.entries(extraRoutes).map(([path, component]) => /* @__PURE__ */ React__default.default.createElement(Route, { key: path, path: `/${path}` }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component }))), /* @__PURE__ */ React__default.default.createElement(Route, { component: ErrorPage, path: "/error" }), /* @__PURE__ */ React__default.default.createElement(Route, { path: "/", render: () => /* @__PURE__ */ React__default.default.createElement(PrivateRoute, null, props.children) }));
59190
59144
  }
59191
59145
  const index = "";
59192
59146
  const ErrorBoundaryContext = React.createContext(null);
@@ -60034,7 +59988,7 @@ Inferred class string: "${iconClasses}."`
60034
59988
  const onClick = () => {
60035
59989
  setIsExpanded((b2) => !b2);
60036
59990
  };
60037
- return /* @__PURE__ */ React__default.default.createElement(ErrorWrapper, null, /* @__PURE__ */ React__default.default.createElement(ErrorHeader, { onClick }, /* @__PURE__ */ React__default.default.createElement(ErrorTitleRow, null, /* @__PURE__ */ React__default.default.createElement(ErrorTitle, null, /* @__PURE__ */ React__default.default.createElement(ErrorSign, { className: "fa-solid fa-triangle-exclamation fa-lg" }), time), /* @__PURE__ */ React__default.default.createElement(Chevron, { $isOpen: isExpanded, className: "fa-solid fa-chevron-down" })), /* @__PURE__ */ React__default.default.createElement(ErrorDescription, null, props.errorMessage.description)), /* @__PURE__ */ React__default.default.createElement(lib$1.Collapse, { isOpened: isExpanded }, /* @__PURE__ */ React__default.default.createElement(CollapseContent, null, /* @__PURE__ */ React__default.default.createElement(ErrorDescription, null, props.errorMessage.tracebackTitle), /* @__PURE__ */ React__default.default.createElement(ErrorTraceback, null, props.errorMessage.traceback))));
59991
+ return /* @__PURE__ */ React__default.default.createElement(ErrorWrapper, null, /* @__PURE__ */ React__default.default.createElement(ErrorHeader, { onClick }, /* @__PURE__ */ React__default.default.createElement(ErrorTitleRow, null, /* @__PURE__ */ React__default.default.createElement(ErrorTitle, null, /* @__PURE__ */ React__default.default.createElement(ErrorSign, { className: "fa-solid fa-triangle-exclamation fa-lg" }), time), /* @__PURE__ */ React__default.default.createElement(Chevron, { $isOpen: isExpanded, className: "fa-solid fa-chevron-down" })), /* @__PURE__ */ React__default.default.createElement(ErrorDescription, null, props.errorMessage.description)), /* @__PURE__ */ React__default.default.createElement(lib.Collapse, { isOpened: isExpanded }, /* @__PURE__ */ React__default.default.createElement(CollapseContent, null, /* @__PURE__ */ React__default.default.createElement(ErrorDescription, null, props.errorMessage.tracebackTitle), /* @__PURE__ */ React__default.default.createElement(ErrorTraceback, null, props.errorMessage.traceback))));
60038
59992
  }
60039
59993
  const ErrorsContainer = styled__default.default.div`
60040
59994
  overflow: hidden;
@@ -86044,7 +85998,6 @@ Inferred class string: "${iconClasses}."`
86044
85998
  const [username, setUsername] = React.useState("");
86045
85999
  const [password, setPassword] = React.useState("");
86046
86000
  const [isError2, setIsError] = React.useState(false);
86047
- const { token, setToken } = React.useContext(authCtx);
86048
86001
  const history2 = useHistory();
86049
86002
  const location2 = useLocation();
86050
86003
  const queryParams = new URLSearchParams(location2.search);
@@ -86053,9 +86006,9 @@ Inferred class string: "${iconClasses}."`
86053
86006
  setIsLoggingIn(true);
86054
86007
  setIsError(false);
86055
86008
  try {
86056
- const sessionToken = await getSessionToken({ password, username });
86009
+ const sessionToken = await requestSessionToken({ password, username });
86057
86010
  if (sessionToken) {
86058
- setToken(sessionToken);
86011
+ setSessionToken(sessionToken);
86059
86012
  history2.replace(decodeURIComponent(previousLocation));
86060
86013
  }
86061
86014
  } catch {
@@ -86064,9 +86017,8 @@ Inferred class string: "${iconClasses}."`
86064
86017
  setIsLoggingIn(false);
86065
86018
  };
86066
86019
  React.useEffect(() => {
86067
- const key = getTokenKey();
86068
- if (token) {
86069
- verifySessionToken(localStorage.getItem(key)).then((verified) => {
86020
+ if (getSessionToken()) {
86021
+ verifySessionToken().then((verified) => {
86070
86022
  if (verified) {
86071
86023
  history2.replace(decodeURIComponent(previousLocation));
86072
86024
  } else {
@@ -86124,10 +86076,9 @@ Inferred class string: "${iconClasses}."`
86124
86076
  ))));
86125
86077
  }
86126
86078
  function BasicAuthLogout() {
86127
- const { setToken, token } = useAuthCtx();
86128
86079
  React.useEffect(() => {
86129
- revokeSession(token).then(() => {
86130
- setToken(null);
86080
+ revokeSession().then(() => {
86081
+ setSessionToken(null);
86131
86082
  window.location.href = `${window.dara.base_url}/login`;
86132
86083
  });
86133
86084
  }, []);
@@ -86135,26 +86086,20 @@ Inferred class string: "${iconClasses}."`
86135
86086
  }
86136
86087
  function DefaultAuthLogin() {
86137
86088
  var _a;
86138
- const { token, setToken } = React.useContext(authCtx);
86139
86089
  const history2 = useHistory();
86140
86090
  const location2 = useLocation();
86141
86091
  const queryParams = new URLSearchParams(location2.search);
86142
86092
  const previousLocation = (_a = queryParams.get("referrer")) != null ? _a : "/";
86143
86093
  async function getNewToken() {
86144
- const sessionToken = await getSessionToken({});
86094
+ const sessionToken = await requestSessionToken({});
86145
86095
  if (sessionToken) {
86146
- setToken(sessionToken);
86096
+ setSessionToken(sessionToken);
86147
86097
  history2.replace(decodeURIComponent(previousLocation));
86148
86098
  }
86149
86099
  }
86150
86100
  React.useEffect(() => {
86151
- const key = getTokenKey();
86152
- if (token) {
86153
- const storedToken = localStorage.getItem(key);
86154
- if (token !== void 0 && token !== null && (!storedToken || storedToken === "undefined")) {
86155
- localStorage.setItem(key, token);
86156
- }
86157
- verifySessionToken(localStorage.getItem(key)).then((verified) => {
86101
+ if (getSessionToken()) {
86102
+ verifySessionToken().then((verified) => {
86158
86103
  if (verified) {
86159
86104
  history2.replace(decodeURIComponent(previousLocation));
86160
86105
  } else {
@@ -86522,7 +86467,6 @@ Inferred class string: "${iconClasses}."`
86522
86467
  exports.useAction = useAction;
86523
86468
  exports.useActionIsLoading = useActionIsLoading;
86524
86469
  exports.useAnyVariable = useAnyVariable;
86525
- exports.useAuthCtx = useAuthCtx;
86526
86470
  exports.useComponentStyles = useComponentStyles;
86527
86471
  exports.useDataVariable = useDataVariable;
86528
86472
  exports.useEventBus = useEventBus;