@depup/jotai 2.18.0-depup.0

package/system/react.development.js

@@ -0,0 +1,210 @@
+'use client';
+System.register(['react', 'jotai/vanilla', 'jotai/vanilla/internals'], (function (exports) {
+  'use strict';
+  var createContext, useContext, useRef, createElement, React, useReducer, useEffect, useDebugValue, useCallback, getDefaultStore, createStore, INTERNAL_getBuildingBlocksRev2;
+  return {
+    setters: [function (module) {
+      createContext = module.createContext;
+      useContext = module.useContext;
+      useRef = module.useRef;
+      createElement = module.createElement;
+      React = module.default;
+      useReducer = module.useReducer;
+      useEffect = module.useEffect;
+      useDebugValue = module.useDebugValue;
+      useCallback = module.useCallback;
+    }, function (module) {
+      getDefaultStore = module.getDefaultStore;
+      createStore = module.createStore;
+    }, function (module) {
+      INTERNAL_getBuildingBlocksRev2 = module.INTERNAL_getBuildingBlocksRev2;
+    }],
+    execute: (function () {
+
+      exports({
+        Provider: Provider,
+        useAtom: useAtom,
+        useAtomValue: useAtomValue,
+        useSetAtom: useSetAtom,
+        useStore: useStore
+      });
+
+      const StoreContext = createContext(
+        void 0
+      );
+      function useStore(options) {
+        const store = useContext(StoreContext);
+        return (options == null ? void 0 : options.store) || store || getDefaultStore();
+      }
+      function Provider({
+        children,
+        store
+      }) {
+        const storeRef = useRef(null);
+        if (store) {
+          return createElement(StoreContext.Provider, { value: store }, children);
+        }
+        if (storeRef.current === null) {
+          storeRef.current = createStore();
+        }
+        return createElement(
+          StoreContext.Provider,
+          {
+            // TODO: If this is not a false positive, consider using useState instead of useRef like https://github.com/pmndrs/jotai/pull/2771
+            // eslint-disable-next-line react-hooks/refs
+            value: storeRef.current
+          },
+          children
+        );
+      }
+
+      const isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
+      const attachPromiseStatus = (promise) => {
+        if (!promise.status) {
+          promise.status = "pending";
+          promise.then(
+            (v) => {
+              promise.status = "fulfilled";
+              promise.value = v;
+            },
+            (e) => {
+              promise.status = "rejected";
+              promise.reason = e;
+            }
+          );
+        }
+      };
+      const use = React.use || // A shim for older React versions
+      ((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;
+        }
+      });
+      const continuablePromiseMap = /* @__PURE__ */ new WeakMap();
+      const createContinuablePromise = (store, promise, getValue) => {
+        const buildingBlocks = INTERNAL_getBuildingBlocksRev2(store);
+        const registerAbortHandler = buildingBlocks[26];
+        let continuablePromise = continuablePromiseMap.get(promise);
+        if (!continuablePromise) {
+          continuablePromise = new Promise((resolve, reject) => {
+            let curr = promise;
+            const onFulfilled = (me) => (v) => {
+              if (curr === me) {
+                resolve(v);
+              }
+            };
+            const onRejected = (me) => (e) => {
+              if (curr === me) {
+                reject(e);
+              }
+            };
+            const onAbort = () => {
+              try {
+                const 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) {
+        const { delay, unstable_promiseStatus: promiseStatus = !React.use } = options || {};
+        const store = useStore(options);
+        const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = useReducer(
+          (prev) => {
+            const nextValue = store.get(atom);
+            if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
+              return prev;
+            }
+            return [nextValue, store, atom];
+          },
+          void 0,
+          () => [store.get(atom), store, atom]
+        );
+        let value = valueFromReducer;
+        if (storeFromReducer !== store || atomFromReducer !== atom) {
+          rerender();
+          value = store.get(atom);
+        }
+        useEffect(() => {
+          const unsub = store.sub(atom, () => {
+            if (promiseStatus) {
+              try {
+                const value2 = store.get(atom);
+                if (isPromiseLike(value2)) {
+                  attachPromiseStatus(
+                    createContinuablePromise(store, value2, () => store.get(atom))
+                  );
+                }
+              } catch (e) {
+              }
+            }
+            if (typeof delay === "number") {
+              setTimeout(rerender, delay);
+              return;
+            }
+            rerender();
+          });
+          rerender();
+          return unsub;
+        }, [store, atom, delay, promiseStatus]);
+        useDebugValue(value);
+        if (isPromiseLike(value)) {
+          const promise = createContinuablePromise(
+            store,
+            value,
+            () => store.get(atom)
+          );
+          if (promiseStatus) {
+            attachPromiseStatus(promise);
+          }
+          return use(promise);
+        }
+        return value;
+      }
+
+      function useSetAtom(atom, options) {
+        const store = useStore(options);
+        const setAtom = useCallback(
+          (...args) => {
+            if (!("write" in atom)) {
+              throw new Error("not writable atom");
+            }
+            return store.set(atom, ...args);
+          },
+          [store, atom]
+        );
+        return setAtom;
+      }
+
+      function useAtom(atom, options) {
+        return [
+          useAtomValue(atom, options),
+          // We do wrong type assertion here, which results in throwing an error.
+          useSetAtom(atom, options)
+        ];
+      }
+
+    })
+  };
+}));

package/system/react.production.js

@@ -0,0 +1,2 @@
+'use client';
+System.register(["react","jotai/vanilla","jotai/vanilla/internals"],(function(V){"use strict";var y,k,p,v,d,C,E,j,m,x,P,w;return{setters:[function(s){y=s.createContext,k=s.useContext,p=s.useRef,v=s.createElement,d=s.default,C=s.useReducer,E=s.useEffect,j=s.useDebugValue,m=s.useCallback},function(s){x=s.getDefaultStore,P=s.createStore},function(s){w=s.INTERNAL_getBuildingBlocksRev2}],execute:(function(){V({Provider:L,useAtom:_,useAtomValue:D,useSetAtom:N,useStore:S});const s=y(void 0);function S(t){const e=k(s);return(t==null?void 0:t.store)||e||x()}function L({children:t,store:e}){const n=p(null);return e?v(s.Provider,{value:e},t):(n.current===null&&(n.current=P()),v(s.Provider,{value:n.current},t))}const h=t=>typeof(t==null?void 0:t.then)=="function",A=t=>{t.status||(t.status="pending",t.then(e=>{t.status="fulfilled",t.value=e},e=>{t.status="rejected",t.reason=e}))},T=d.use||(t=>{if(t.status==="pending")throw t;if(t.status==="fulfilled")return t.value;throw t.status==="rejected"?t.reason:(A(t),t)}),b=new WeakMap,B=(t,e,n)=>{const c=w(t)[26];let r=b.get(e);return r||(r=new Promise((f,g)=>{let l=e;const i=u=>R=>{l===u&&f(R)},a=u=>R=>{l===u&&g(R)},o=()=>{try{const u=n();h(u)?(b.set(u,r),l=u,u.then(i(u),a(u)),c(t,u,o)):f(u)}catch(u){g(u)}};e.then(i(e),a(e)),c(t,e,o)}),b.set(e,r)),r};function D(t,e){const{delay:n,unstable_promiseStatus:c=!d.use}=e||{},r=S(e),[[f,g,l],i]=C(o=>{const u=r.get(t);return Object.is(o[0],u)&&o[1]===r&&o[2]===t?o:[u,r,t]},void 0,()=>[r.get(t),r,t]);let a=f;if((g!==r||l!==t)&&(i(),a=r.get(t)),E(()=>{const o=r.sub(t,()=>{if(c)try{const u=r.get(t);h(u)&&A(B(r,u,()=>r.get(t)))}catch(u){}if(typeof n=="number"){setTimeout(i,n);return}i()});return i(),o},[r,t,n,c]),j(a),h(a)){const o=B(r,a,()=>r.get(t));return c&&A(o),T(o)}return a}function N(t,e){const n=S(e);return m((...c)=>n.set(t,...c),[n,t])}function _(t,e){return[D(t,e),N(t,e)]}})}}));

package/system/utils.development.js

@@ -0,0 +1,27 @@
+System.register(['jotai/vanilla/utils', 'jotai/react/utils'], (function (exports) {
+	'use strict';
+	var _starExcludes = {
+		__proto__: null,
+		default: 1
+	};
+	return {
+		setters: [function (module) {
+			var setter = { __proto__: null };
+			for (var name in module) {
+				if (!_starExcludes[name]) setter[name] = module[name];
+			}
+			exports(setter);
+		}, function (module) {
+			var setter = { __proto__: null };
+			for (var name in module) {
+				if (!_starExcludes[name]) setter[name] = module[name];
+			}
+			exports(setter);
+		}],
+		execute: (function () {
+
+
+
+		})
+	};
+}));

package/system/utils.production.js

@@ -0,0 +1 @@
+System.register(["jotai/vanilla/utils","jotai/react/utils"],(function(_){"use strict";var u={__proto__:null,default:1};return{setters:[function(r){var i={__proto__:null};for(var t in r)u[t]||(i[t]=r[t]);_(i)},function(r){var i={__proto__:null};for(var t in r)u[t]||(i[t]=r[t]);_(i)}],execute:(function(){})}}));