@depup/jotai 2.18.0-depup.0

package/umd/react/utils.development.js

@@ -0,0 +1,101 @@
+'use client';
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('jotai/react'), require('jotai/vanilla/utils'), require('jotai/vanilla')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', 'jotai/react', 'jotai/vanilla/utils', 'jotai/vanilla'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jotaiReactUtils = {}, global.React, global.jotaiReact, global.jotaiVanillaUtils, global.jotaiVanilla));
+})(this, (function (exports, react$1, react, utils, vanilla) { 'use strict';
+
+  function useResetAtom(anAtom, options) {
+    var setAtom = react.useSetAtom(anAtom, options);
+    var resetAtom = react$1.useCallback(function () {
+      return setAtom(utils.RESET);
+    }, [setAtom]);
+    return resetAtom;
+  }
+
+  function useReducerAtom(anAtom, reducer, options) {
+    {
+      console.warn('[DEPRECATED] useReducerAtom is deprecated and will be removed in the future. Please create your own version using the recipe. https://github.com/pmndrs/jotai/pull/2467');
+    }
+    var _useAtom = react.useAtom(anAtom, options),
+      state = _useAtom[0],
+      setState = _useAtom[1];
+    var dispatch = react$1.useCallback(function (action) {
+      setState(function (prev) {
+        return reducer(prev, action);
+      });
+    }, [setState, reducer]);
+    return [state, dispatch];
+  }
+
+  function useAtomCallback(callback, options) {
+    var anAtom = react$1.useMemo(function () {
+      return vanilla.atom(null, function (get, set) {
+        for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+          args[_key - 2] = arguments[_key];
+        }
+        return callback.apply(void 0, [get, set].concat(args));
+      });
+    }, [callback]);
+    return react.useSetAtom(anAtom, options);
+  }
+
+  function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _createForOfIteratorHelperLoose(r, e) {
+    var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (t) return (t = t.call(r)).next.bind(t);
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+      t && (r = t);
+      var o = 0;
+      return function () {
+        return o >= r.length ? {
+          done: true
+        } : {
+          done: false,
+          value: r[o++]
+        };
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _unsupportedIterableToArray(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+    }
+  }
+
+  var hydratedMap = new WeakMap();
+  function useHydrateAtoms(values, options) {
+    var store = react.useStore(options);
+    var hydratedSet = getHydratedSet(store);
+    for (var _iterator = _createForOfIteratorHelperLoose(values), _step; !(_step = _iterator()).done;) {
+      var _step$value = _step.value,
+        atom = _step$value[0],
+        args = _arrayLikeToArray(_step$value).slice(1);
+      if (!hydratedSet.has(atom) || options != null && options.dangerouslyForceHydrate) {
+        hydratedSet.add(atom);
+        store.set.apply(store, [atom].concat(args));
+      }
+    }
+  }
+  var getHydratedSet = function getHydratedSet(store) {
+    var hydratedSet = hydratedMap.get(store);
+    if (!hydratedSet) {
+      hydratedSet = new WeakSet();
+      hydratedMap.set(store, hydratedSet);
+    }
+    return hydratedSet;
+  };
+
+  exports.useAtomCallback = useAtomCallback;
+  exports.useHydrateAtoms = useHydrateAtoms;
+  exports.useReducerAtom = useReducerAtom;
+  exports.useResetAtom = useResetAtom;
+
+}));

package/umd/react/utils.production.js

@@ -0,0 +1 @@
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("react"),require("jotai/react"),require("jotai/vanilla/utils"),require("jotai/vanilla")):"function"==typeof define&&define.amd?define(["exports","react","jotai/react","jotai/vanilla/utils","jotai/vanilla"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).jotaiReactUtils={},t.React,t.jotaiReact,t.jotaiVanillaUtils,t.jotaiVanilla)}(this,function(t,e,r,n,a){"use strict";function o(t,e){(null==e||e>t.length)&&(e=t.length);for(var r=0,n=Array(e);r<e;r++)n[r]=t[r];return n}function i(t,e){var r="undefined"!=typeof Symbol&&t[Symbol.iterator]||t["@@iterator"];if(r)return(r=r.call(t)).next.bind(r);if(Array.isArray(t)||(r=function(t,e){if(t){if("string"==typeof t)return o(t,e);var r={}.toString.call(t).slice(8,-1);return"Object"===r&&t.constructor&&(r=t.constructor.name),"Map"===r||"Set"===r?Array.from(t):"Arguments"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)?o(t,e):void 0}}(t))||e){r&&(t=r);var n=0;return function(){return n>=t.length?{done:!0}:{done:!1,value:t[n++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var u=new WeakMap;var l=function(t){var e=u.get(t);return e||(e=new WeakSet,u.set(t,e)),e};t.useAtomCallback=function(t,n){var o=e.useMemo(function(){return a.atom(null,function(e,r){for(var n=arguments.length,a=new Array(n>2?n-2:0),o=2;o<n;o++)a[o-2]=arguments[o];return t.apply(void 0,[e,r].concat(a))})},[t]);return r.useSetAtom(o,n)},t.useHydrateAtoms=function(t,e){for(var n,a=r.useStore(e),u=l(a),c=i(t);!(n=c()).done;){var s=n.value,f=s[0],d=o(s).slice(1);(!u.has(f)||null!=e&&e.dangerouslyForceHydrate)&&(u.add(f),a.set.apply(a,[f].concat(d)))}},t.useReducerAtom=function(t,n,a){var o=r.useAtom(t,a),i=o[0],u=o[1];return[i,e.useCallback(function(t){u(function(e){return n(e,t)})},[u,n])]},t.useResetAtom=function(t,a){var o=r.useSetAtom(t,a);return e.useCallback(function(){return o(n.RESET)},[o])}});

package/umd/react.development.js

@@ -0,0 +1,184 @@
+'use client';
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('jotai/vanilla'), require('jotai/vanilla/internals')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', 'jotai/vanilla', 'jotai/vanilla/internals'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jotaiReact = {}, global.React, global.jotaiVanilla, global.jotaiVanillaInternals));
+})(this, (function (exports, React, vanilla, internals) { 'use strict';
+
+  var StoreContext = React.createContext(undefined);
+  function useStore(options) {
+    var store = React.useContext(StoreContext);
+    return (options == null ? void 0 : options.store) || store || vanilla.getDefaultStore();
+  }
+  function Provider(_ref) {
+    var children = _ref.children,
+      store = _ref.store;
+    var storeRef = React.useRef(null);
+    if (store) {
+      return React.createElement(StoreContext.Provider, {
+        value: store
+      }, children);
+    }
+    if (storeRef.current === null) {
+      storeRef.current = vanilla.createStore();
+    }
+    return React.createElement(StoreContext.Provider, {
+      value: storeRef.current
+    }, children);
+  }
+
+  var isPromiseLike = function isPromiseLike(x) {
+    return typeof (x == null ? void 0 : x.then) === 'function';
+  };
+  var attachPromiseStatus = function attachPromiseStatus(promise) {
+    if (!promise.status) {
+      promise.status = 'pending';
+      promise.then(function (v) {
+        promise.status = 'fulfilled';
+        promise.value = v;
+      }, function (e) {
+        promise.status = 'rejected';
+        promise.reason = e;
+      });
+    }
+  };
+  var use = React.use || function (promise) {
+    if (promise.status === 'pending') {
+      throw promise;
+    } else if (promise.status === 'fulfilled') {
+      return promise.value;
+    } else if (promise.status === 'rejected') {
+      throw promise.reason;
+    } else {
+      attachPromiseStatus(promise);
+      throw promise;
+    }
+  };
+  var continuablePromiseMap = new WeakMap();
+  var createContinuablePromise = function createContinuablePromise(store, promise, getValue) {
+    var buildingBlocks = internals.INTERNAL_getBuildingBlocksRev2(store);
+    var registerAbortHandler = buildingBlocks[26];
+    var continuablePromise = continuablePromiseMap.get(promise);
+    if (!continuablePromise) {
+      continuablePromise = new Promise(function (resolve, reject) {
+        var curr = promise;
+        var onFulfilled = function onFulfilled(me) {
+          return function (v) {
+            if (curr === me) {
+              resolve(v);
+            }
+          };
+        };
+        var onRejected = function onRejected(me) {
+          return function (e) {
+            if (curr === me) {
+              reject(e);
+            }
+          };
+        };
+        var _onAbort = function onAbort() {
+          try {
+            var nextValue = getValue();
+            if (isPromiseLike(nextValue)) {
+              continuablePromiseMap.set(nextValue, continuablePromise);
+              curr = nextValue;
+              nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
+              registerAbortHandler(store, nextValue, _onAbort);
+            } else {
+              resolve(nextValue);
+            }
+          } catch (e) {
+            reject(e);
+          }
+        };
+        promise.then(onFulfilled(promise), onRejected(promise));
+        registerAbortHandler(store, promise, _onAbort);
+      });
+      continuablePromiseMap.set(promise, continuablePromise);
+    }
+    return continuablePromise;
+  };
+  function useAtomValue(atom, options) {
+    var _ref = options || {},
+      delay = _ref.delay,
+      _ref$unstable_promise = _ref.unstable_promiseStatus,
+      promiseStatus = _ref$unstable_promise === void 0 ? !React.use : _ref$unstable_promise;
+    var store = useStore(options);
+    var _useReducer = React.useReducer(function (prev) {
+        var nextValue = store.get(atom);
+        if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
+          return prev;
+        }
+        return [nextValue, store, atom];
+      }, undefined, function () {
+        return [store.get(atom), store, atom];
+      }),
+      _useReducer$ = _useReducer[0],
+      valueFromReducer = _useReducer$[0],
+      storeFromReducer = _useReducer$[1],
+      atomFromReducer = _useReducer$[2],
+      rerender = _useReducer[1];
+    var value = valueFromReducer;
+    if (storeFromReducer !== store || atomFromReducer !== atom) {
+      rerender();
+      value = store.get(atom);
+    }
+    React.useEffect(function () {
+      var unsub = store.sub(atom, function () {
+        if (promiseStatus) {
+          try {
+            var _value = store.get(atom);
+            if (isPromiseLike(_value)) {
+              attachPromiseStatus(createContinuablePromise(store, _value, function () {
+                return store.get(atom);
+              }));
+            }
+          } catch (_unused) {}
+        }
+        if (typeof delay === 'number') {
+          setTimeout(rerender, delay);
+          return;
+        }
+        rerender();
+      });
+      rerender();
+      return unsub;
+    }, [store, atom, delay, promiseStatus]);
+    React.useDebugValue(value);
+    if (isPromiseLike(value)) {
+      var promise = createContinuablePromise(store, value, function () {
+        return store.get(atom);
+      });
+      if (promiseStatus) {
+        attachPromiseStatus(promise);
+      }
+      return use(promise);
+    }
+    return value;
+  }
+
+  function useSetAtom(atom, options) {
+    var store = useStore(options);
+    var setAtom = React.useCallback(function () {
+      if (!('write' in atom)) {
+        throw new Error('not writable atom');
+      }
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return store.set.apply(store, [atom].concat(args));
+    }, [store, atom]);
+    return setAtom;
+  }
+
+  function useAtom(atom, options) {
+    return [useAtomValue(atom, options), useSetAtom(atom, options)];
+  }
+
+  exports.Provider = Provider;
+  exports.useAtom = useAtom;
+  exports.useAtomValue = useAtomValue;
+  exports.useSetAtom = useSetAtom;
+  exports.useStore = useStore;
+
+}));

package/umd/react.production.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("react"),require("jotai/vanilla"),require("jotai/vanilla/internals")):"function"==typeof define&&define.amd?define(["exports","react","jotai/vanilla","jotai/vanilla/internals"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).jotaiReact={},e.React,e.jotaiVanilla,e.jotaiVanillaInternals)}(this,function(e,t,n,r){"use strict";var u=t.createContext(void 0);function i(e){var r=t.useContext(u);return(null==e?void 0:e.store)||r||n.getDefaultStore()}var o=function(e){return"function"==typeof(null==e?void 0:e.then)},a=function(e){e.status||(e.status="pending",e.then(function(t){e.status="fulfilled",e.value=t},function(t){e.status="rejected",e.reason=t}))},c=t.use||function(e){if("pending"===e.status)throw e;if("fulfilled"===e.status)return e.value;throw"rejected"===e.status?e.reason:(a(e),e)},f=new WeakMap,l=function(e,t,n){var u=r.INTERNAL_getBuildingBlocksRev2(e)[26],i=f.get(t);return i||(i=new Promise(function(r,a){var c=t,l=function(e){return function(t){c===e&&r(t)}},s=function(e){return function(t){c===e&&a(t)}},v=function(){try{var t=n();o(t)?(f.set(t,i),c=t,t.then(l(t),s(t)),u(e,t,v)):r(t)}catch(e){a(e)}};t.then(l(t),s(t)),u(e,t,v)}),f.set(t,i)),i};function s(e,n){var r=n||{},u=r.delay,f=r.unstable_promiseStatus,s=void 0===f?!t.use:f,v=i(n),d=t.useReducer(function(t){var n=v.get(e);return Object.is(t[0],n)&&t[1]===v&&t[2]===e?t:[n,v,e]},void 0,function(){return[v.get(e),v,e]}),g=d[0],p=g[0],h=g[1],j=g[2],m=d[1],y=p;if(h===v&&j===e||(m(),y=v.get(e)),t.useEffect(function(){var t=v.sub(e,function(){if(s)try{var t=v.get(e);o(t)&&a(l(v,t,function(){return v.get(e)}))}catch(e){}"number"!=typeof u?m():setTimeout(m,u)});return m(),t},[v,e,u,s]),t.useDebugValue(y),o(y)){var b=l(v,y,function(){return v.get(e)});return s&&a(b),c(b)}return y}function v(e,n){var r=i(n),u=t.useCallback(function(){for(var t=arguments.length,n=new Array(t),u=0;u<t;u++)n[u]=arguments[u];return r.set.apply(r,[e].concat(n))},[r,e]);return u}e.Provider=function(e){var r=e.children,i=e.store,o=t.useRef(null);return i?t.createElement(u.Provider,{value:i},r):(null===o.current&&(o.current=n.createStore()),t.createElement(u.Provider,{value:o.current},r))},e.useAtom=function(e,t){return[s(e,t),v(e,t)]},e.useAtomValue=s,e.useSetAtom=v,e.useStore=i});

package/umd/utils.development.js

@@ -0,0 +1,20 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jotai/vanilla/utils'), require('jotai/react/utils')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'jotai/vanilla/utils', 'jotai/react/utils'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jotaiUtils = {}, global.jotaiVanillaUtils, global.jotaiReactUtils));
+})(this, (function (exports, utils$1, utils) { 'use strict';
+
+	Object.keys(utils$1).forEach(function (k) {
+		if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+			enumerable: true,
+			get: function () { return utils$1[k]; }
+		});
+	});
+	Object.keys(utils).forEach(function (k) {
+		if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+			enumerable: true,
+			get: function () { return utils[k]; }
+		});
+	});
+
+}));

package/umd/utils.production.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("jotai/vanilla/utils"),require("jotai/react/utils")):"function"==typeof define&&define.amd?define(["exports","jotai/vanilla/utils","jotai/react/utils"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).jotaiUtils={},e.jotaiVanillaUtils,e.jotaiReactUtils)}(this,function(e,t,i){"use strict";Object.keys(t).forEach(function(i){"default"===i||Object.prototype.hasOwnProperty.call(e,i)||Object.defineProperty(e,i,{enumerable:!0,get:function(){return t[i]}})}),Object.keys(i).forEach(function(t){"default"===t||Object.prototype.hasOwnProperty.call(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:function(){return i[t]}})})});