1 | System.register(['react'], (function (exports) {
|
2 | 'use strict';
|
3 | var createContext, useState, useEffect, useDebugValue, useRef, createElement, useContext, useCallback, useReducer;
|
4 | return {
|
5 | setters: [function (module) {
|
6 | createContext = module.createContext;
|
7 | useState = module.useState;
|
8 | useEffect = module.useEffect;
|
9 | useDebugValue = module.useDebugValue;
|
10 | useRef = module.useRef;
|
11 | createElement = module.createElement;
|
12 | useContext = module.useContext;
|
13 | useCallback = module.useCallback;
|
14 | useReducer = module.useReducer;
|
15 | }],
|
16 | execute: (function () {
|
17 |
|
18 | exports({
|
19 | atom: atom,
|
20 | useAtom: useAtom,
|
21 | useAtomValue: useAtomValue,
|
22 | useSetAtom: useSetAtom
|
23 | });
|
24 |
|
25 | const SUSPENSE_PROMISE = Symbol();
|
26 | const isSuspensePromise = (promise) => !!promise[SUSPENSE_PROMISE];
|
27 | const isSuspensePromiseAlreadyCancelled = (suspensePromise) => !suspensePromise[SUSPENSE_PROMISE].c;
|
28 | const cancelSuspensePromise = (suspensePromise) => {
|
29 | var _a, _b;
|
30 | (_b = (_a = suspensePromise[SUSPENSE_PROMISE]).c) == null ? void 0 : _b.call(_a);
|
31 | };
|
32 | const isEqualSuspensePromise = (oldSuspensePromise, newSuspensePromise) => {
|
33 | const oldOriginalPromise = oldSuspensePromise[SUSPENSE_PROMISE].o;
|
34 | const newOriginalPromise = newSuspensePromise[SUSPENSE_PROMISE].o;
|
35 | return oldOriginalPromise === newOriginalPromise || oldSuspensePromise === newOriginalPromise || isSuspensePromise(oldOriginalPromise) && isEqualSuspensePromise(oldOriginalPromise, newSuspensePromise);
|
36 | };
|
37 | const createSuspensePromise = (promise) => {
|
38 | const objectToAttach = {
|
39 | o: promise,
|
40 | c: null
|
41 | };
|
42 | const suspensePromise = new Promise((resolve) => {
|
43 | objectToAttach.c = () => {
|
44 | objectToAttach.c = null;
|
45 | resolve();
|
46 | };
|
47 | promise.then(objectToAttach.c, objectToAttach.c);
|
48 | });
|
49 | suspensePromise[SUSPENSE_PROMISE] = objectToAttach;
|
50 | return suspensePromise;
|
51 | };
|
52 |
|
53 | var __defProp$1 = Object.defineProperty;
|
54 | var __defProps$1 = Object.defineProperties;
|
55 | var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
|
56 | var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
|
57 | var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
|
58 | var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
|
59 | var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
60 | var __spreadValues$1 = (a, b) => {
|
61 | for (var prop in b || (b = {}))
|
62 | if (__hasOwnProp$1.call(b, prop))
|
63 | __defNormalProp$1(a, prop, b[prop]);
|
64 | if (__getOwnPropSymbols$1)
|
65 | for (var prop of __getOwnPropSymbols$1(b)) {
|
66 | if (__propIsEnum$1.call(b, prop))
|
67 | __defNormalProp$1(a, prop, b[prop]);
|
68 | }
|
69 | return a;
|
70 | };
|
71 | var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
|
72 | const hasInitialValue = (atom) => "init" in atom;
|
73 | const READ_ATOM = "r";
|
74 | const WRITE_ATOM = "w";
|
75 | const COMMIT_ATOM = "c";
|
76 | const SUBSCRIBE_ATOM = "s";
|
77 | const RESTORE_ATOMS = "h";
|
78 | const DEV_SUBSCRIBE_STATE = "n";
|
79 | const DEV_GET_MOUNTED_ATOMS = "l";
|
80 | const DEV_GET_ATOM_STATE = "a";
|
81 | const DEV_GET_MOUNTED = "m";
|
82 | const createStore = (initialValues) => {
|
83 | const committedAtomStateMap = new WeakMap();
|
84 | const mountedMap = new WeakMap();
|
85 | const pendingMap = new Map();
|
86 | let stateListeners;
|
87 | let mountedAtoms;
|
88 | {
|
89 | stateListeners = new Set();
|
90 | mountedAtoms = new Set();
|
91 | }
|
92 | if (initialValues) {
|
93 | for (const [atom, value] of initialValues) {
|
94 | const atomState = { v: value, r: 0, d: new Map() };
|
95 | {
|
96 | Object.freeze(atomState);
|
97 | if (!hasInitialValue(atom)) {
|
98 | console.warn("Found initial value for derived atom which can cause unexpected behavior", atom);
|
99 | }
|
100 | }
|
101 | committedAtomStateMap.set(atom, atomState);
|
102 | }
|
103 | }
|
104 | const suspensePromiseCacheMap = new WeakMap();
|
105 | const addSuspensePromiseToCache = (version, atom, suspensePromise) => {
|
106 | let cache = suspensePromiseCacheMap.get(atom);
|
107 | if (!cache) {
|
108 | cache = new Map();
|
109 | suspensePromiseCacheMap.set(atom, cache);
|
110 | }
|
111 | suspensePromise.then(() => {
|
112 | if (cache.get(version) === suspensePromise) {
|
113 | cache.delete(version);
|
114 | if (!cache.size) {
|
115 | suspensePromiseCacheMap.delete(atom);
|
116 | }
|
117 | }
|
118 | });
|
119 | cache.set(version, suspensePromise);
|
120 | };
|
121 | const cancelAllSuspensePromiseInCache = (atom) => {
|
122 | const versionSet = new Set();
|
123 | const cache = suspensePromiseCacheMap.get(atom);
|
124 | if (cache) {
|
125 | suspensePromiseCacheMap.delete(atom);
|
126 | cache.forEach((suspensePromise, version) => {
|
127 | cancelSuspensePromise(suspensePromise);
|
128 | versionSet.add(version);
|
129 | });
|
130 | }
|
131 | return versionSet;
|
132 | };
|
133 | const versionedAtomStateMapMap = new WeakMap();
|
134 | const getVersionedAtomStateMap = (version) => {
|
135 | let versionedAtomStateMap = versionedAtomStateMapMap.get(version);
|
136 | if (!versionedAtomStateMap) {
|
137 | versionedAtomStateMap = new Map();
|
138 | versionedAtomStateMapMap.set(version, versionedAtomStateMap);
|
139 | }
|
140 | return versionedAtomStateMap;
|
141 | };
|
142 | const getAtomState = (version, atom) => {
|
143 | if (version) {
|
144 | const versionedAtomStateMap = getVersionedAtomStateMap(version);
|
145 | let atomState = versionedAtomStateMap.get(atom);
|
146 | if (!atomState) {
|
147 | atomState = getAtomState(version.p, atom);
|
148 | if (atomState) {
|
149 | if ("p" in atomState) {
|
150 | atomState.p.then(() => versionedAtomStateMap.delete(atom));
|
151 | }
|
152 | versionedAtomStateMap.set(atom, atomState);
|
153 | }
|
154 | }
|
155 | return atomState;
|
156 | }
|
157 | return committedAtomStateMap.get(atom);
|
158 | };
|
159 | const setAtomState = (version, atom, atomState) => {
|
160 | {
|
161 | Object.freeze(atomState);
|
162 | }
|
163 | if (version) {
|
164 | const versionedAtomStateMap = getVersionedAtomStateMap(version);
|
165 | versionedAtomStateMap.set(atom, atomState);
|
166 | } else {
|
167 | const prevAtomState = committedAtomStateMap.get(atom);
|
168 | committedAtomStateMap.set(atom, atomState);
|
169 | if (!pendingMap.has(atom)) {
|
170 | pendingMap.set(atom, prevAtomState);
|
171 | }
|
172 | }
|
173 | };
|
174 | const createReadDependencies = (version, prevReadDependencies = /* @__PURE__ */ new Map(), dependencies) => {
|
175 | if (!dependencies) {
|
176 | return prevReadDependencies;
|
177 | }
|
178 | const readDependencies = new Map();
|
179 | let changed = false;
|
180 | dependencies.forEach((atom) => {
|
181 | var _a;
|
182 | const revision = ((_a = getAtomState(version, atom)) == null ? void 0 : _a.r) || 0;
|
183 | readDependencies.set(atom, revision);
|
184 | if (prevReadDependencies.get(atom) !== revision) {
|
185 | changed = true;
|
186 | }
|
187 | });
|
188 | if (prevReadDependencies.size === readDependencies.size && !changed) {
|
189 | return prevReadDependencies;
|
190 | }
|
191 | return readDependencies;
|
192 | };
|
193 | const setAtomValue = (version, atom, value, dependencies, suspensePromise) => {
|
194 | const atomState = getAtomState(version, atom);
|
195 | if (atomState) {
|
196 | if (suspensePromise && (!("p" in atomState) || !isEqualSuspensePromise(atomState.p, suspensePromise))) {
|
197 | return atomState;
|
198 | }
|
199 | if ("p" in atomState) {
|
200 | cancelSuspensePromise(atomState.p);
|
201 | }
|
202 | }
|
203 | const nextAtomState = {
|
204 | v: value,
|
205 | r: (atomState == null ? void 0 : atomState.r) || 0,
|
206 | d: createReadDependencies(version, atomState == null ? void 0 : atomState.d, dependencies)
|
207 | };
|
208 | if (!atomState || !("v" in atomState) || !Object.is(atomState.v, value)) {
|
209 | ++nextAtomState.r;
|
210 | if (nextAtomState.d.has(atom)) {
|
211 | nextAtomState.d = new Map(nextAtomState.d).set(atom, nextAtomState.r);
|
212 | }
|
213 | } else if (nextAtomState.d !== atomState.d && (nextAtomState.d.size !== atomState.d.size || !Array.from(nextAtomState.d.keys()).every((a) => atomState.d.has(a)))) {
|
214 | Promise.resolve().then(() => {
|
215 | flushPending(version);
|
216 | });
|
217 | }
|
218 | setAtomState(version, atom, nextAtomState);
|
219 | return nextAtomState;
|
220 | };
|
221 | const setAtomReadError = (version, atom, error, dependencies, suspensePromise) => {
|
222 | const atomState = getAtomState(version, atom);
|
223 | if (atomState) {
|
224 | if (suspensePromise && (!("p" in atomState) || !isEqualSuspensePromise(atomState.p, suspensePromise))) {
|
225 | return atomState;
|
226 | }
|
227 | if ("p" in atomState) {
|
228 | cancelSuspensePromise(atomState.p);
|
229 | }
|
230 | }
|
231 | const nextAtomState = {
|
232 | e: error,
|
233 | r: (atomState == null ? void 0 : atomState.r) || 0,
|
234 | d: createReadDependencies(version, atomState == null ? void 0 : atomState.d, dependencies)
|
235 | };
|
236 | setAtomState(version, atom, nextAtomState);
|
237 | return nextAtomState;
|
238 | };
|
239 | const setAtomSuspensePromise = (version, atom, suspensePromise, dependencies) => {
|
240 | const atomState = getAtomState(version, atom);
|
241 | if (atomState && "p" in atomState) {
|
242 | if (isEqualSuspensePromise(atomState.p, suspensePromise)) {
|
243 | return atomState;
|
244 | }
|
245 | cancelSuspensePromise(atomState.p);
|
246 | }
|
247 | addSuspensePromiseToCache(version, atom, suspensePromise);
|
248 | const nextAtomState = {
|
249 | p: suspensePromise,
|
250 | r: (atomState == null ? void 0 : atomState.r) || 0,
|
251 | d: createReadDependencies(version, atomState == null ? void 0 : atomState.d, dependencies)
|
252 | };
|
253 | setAtomState(version, atom, nextAtomState);
|
254 | return nextAtomState;
|
255 | };
|
256 | const setAtomPromiseOrValue = (version, atom, promiseOrValue, dependencies) => {
|
257 | if (promiseOrValue instanceof Promise) {
|
258 | const suspensePromise = createSuspensePromise(promiseOrValue.then((value) => {
|
259 | setAtomValue(version, atom, value, dependencies, suspensePromise);
|
260 | flushPending(version);
|
261 | }).catch((e) => {
|
262 | if (e instanceof Promise) {
|
263 | if (isSuspensePromise(e)) {
|
264 | return e.then(() => {
|
265 | readAtomState(version, atom, true);
|
266 | });
|
267 | }
|
268 | return e;
|
269 | }
|
270 | setAtomReadError(version, atom, e, dependencies, suspensePromise);
|
271 | flushPending(version);
|
272 | }));
|
273 | return setAtomSuspensePromise(version, atom, suspensePromise, dependencies);
|
274 | }
|
275 | return setAtomValue(version, atom, promiseOrValue, dependencies);
|
276 | };
|
277 | const setAtomInvalidated = (version, atom) => {
|
278 | const atomState = getAtomState(version, atom);
|
279 | if (atomState) {
|
280 | if ("p" in atomState) {
|
281 | cancelSuspensePromise(atomState.p);
|
282 | }
|
283 | const nextAtomState = __spreadProps$1(__spreadValues$1({}, atomState), {
|
284 | i: atomState.r
|
285 | });
|
286 | setAtomState(version, atom, nextAtomState);
|
287 | } else {
|
288 | console.warn("[Bug] could not invalidate non existing atom", atom);
|
289 | }
|
290 | };
|
291 | const readAtomState = (version, atom, force) => {
|
292 | if (!force) {
|
293 | const atomState = getAtomState(version, atom);
|
294 | if (atomState) {
|
295 | if (atomState.r !== atomState.i && "p" in atomState && !isSuspensePromiseAlreadyCancelled(atomState.p)) {
|
296 | return atomState;
|
297 | }
|
298 | atomState.d.forEach((_, a) => {
|
299 | if (a !== atom) {
|
300 | if (!mountedMap.has(a)) {
|
301 | readAtomState(version, a);
|
302 | } else {
|
303 | const aState = getAtomState(version, a);
|
304 | if (aState && aState.r === aState.i) {
|
305 | readAtomState(version, a);
|
306 | }
|
307 | }
|
308 | }
|
309 | });
|
310 | if (Array.from(atomState.d).every(([a, r]) => {
|
311 | const aState = getAtomState(version, a);
|
312 | return aState && "v" in aState && aState.r === r;
|
313 | })) {
|
314 | return atomState;
|
315 | }
|
316 | }
|
317 | }
|
318 | const dependencies = new Set();
|
319 | try {
|
320 | const promiseOrValue = atom.read((a) => {
|
321 | dependencies.add(a);
|
322 | const aState = a === atom ? getAtomState(version, a) : readAtomState(version, a);
|
323 | if (aState) {
|
324 | if ("e" in aState) {
|
325 | throw aState.e;
|
326 | }
|
327 | if ("p" in aState) {
|
328 | throw aState.p;
|
329 | }
|
330 | return aState.v;
|
331 | }
|
332 | if (hasInitialValue(a)) {
|
333 | return a.init;
|
334 | }
|
335 | throw new Error("no atom init");
|
336 | });
|
337 | return setAtomPromiseOrValue(version, atom, promiseOrValue, dependencies);
|
338 | } catch (errorOrPromise) {
|
339 | if (errorOrPromise instanceof Promise) {
|
340 | const suspensePromise = createSuspensePromise(errorOrPromise);
|
341 | return setAtomSuspensePromise(version, atom, suspensePromise, dependencies);
|
342 | }
|
343 | return setAtomReadError(version, atom, errorOrPromise, dependencies);
|
344 | }
|
345 | };
|
346 | const readAtom = (readingAtom, version) => {
|
347 | const atomState = readAtomState(version, readingAtom);
|
348 | return atomState;
|
349 | };
|
350 | const addAtom = (addingAtom) => {
|
351 | let mounted = mountedMap.get(addingAtom);
|
352 | if (!mounted) {
|
353 | mounted = mountAtom(addingAtom);
|
354 | }
|
355 | return mounted;
|
356 | };
|
357 | const canUnmountAtom = (atom, mounted) => !mounted.l.size && (!mounted.t.size || mounted.t.size === 1 && mounted.t.has(atom));
|
358 | const delAtom = (deletingAtom) => {
|
359 | const mounted = mountedMap.get(deletingAtom);
|
360 | if (mounted && canUnmountAtom(deletingAtom, mounted)) {
|
361 | unmountAtom(deletingAtom);
|
362 | }
|
363 | };
|
364 | const invalidateDependents = (version, atom) => {
|
365 | const mounted = mountedMap.get(atom);
|
366 | mounted == null ? void 0 : mounted.t.forEach((dependent) => {
|
367 | if (dependent !== atom) {
|
368 | setAtomInvalidated(version, dependent);
|
369 | invalidateDependents(version, dependent);
|
370 | }
|
371 | });
|
372 | };
|
373 | const writeAtomState = (version, atom, update) => {
|
374 | let isSync = true;
|
375 | const writeGetter = (a, options) => {
|
376 | const aState = readAtomState(version, a);
|
377 | if ("e" in aState) {
|
378 | throw aState.e;
|
379 | }
|
380 | if ("p" in aState) {
|
381 | if (options == null ? void 0 : options.unstable_promise) {
|
382 | return aState.p.then(() => writeGetter(a, options));
|
383 | }
|
384 | {
|
385 | console.info("Reading pending atom state in write operation. We throw a promise for now.", a);
|
386 | }
|
387 | throw aState.p;
|
388 | }
|
389 | if ("v" in aState) {
|
390 | return aState.v;
|
391 | }
|
392 | {
|
393 | console.warn("[Bug] no value found while reading atom in write operation. This is probably a bug.", a);
|
394 | }
|
395 | throw new Error("no value found");
|
396 | };
|
397 | const setter = (a, v) => {
|
398 | let promiseOrVoid2;
|
399 | if (a === atom) {
|
400 | if (!hasInitialValue(a)) {
|
401 | throw new Error("atom not writable");
|
402 | }
|
403 | const versionSet = cancelAllSuspensePromiseInCache(a);
|
404 | versionSet.forEach((cancelledVersion) => {
|
405 | if (cancelledVersion !== version) {
|
406 | setAtomPromiseOrValue(cancelledVersion, a, v);
|
407 | }
|
408 | });
|
409 | setAtomPromiseOrValue(version, a, v);
|
410 | invalidateDependents(version, a);
|
411 | } else {
|
412 | promiseOrVoid2 = writeAtomState(version, a, v);
|
413 | }
|
414 | if (!isSync) {
|
415 | flushPending(version);
|
416 | }
|
417 | return promiseOrVoid2;
|
418 | };
|
419 | const promiseOrVoid = atom.write(writeGetter, setter, update);
|
420 | isSync = false;
|
421 | version = void 0;
|
422 | return promiseOrVoid;
|
423 | };
|
424 | const writeAtom = (writingAtom, update, version) => {
|
425 | const promiseOrVoid = writeAtomState(version, writingAtom, update);
|
426 | flushPending(version);
|
427 | return promiseOrVoid;
|
428 | };
|
429 | const isActuallyWritableAtom = (atom) => !!atom.write;
|
430 | const mountAtom = (atom, initialDependent) => {
|
431 | const mounted = {
|
432 | t: new Set(initialDependent && [initialDependent]),
|
433 | l: new Set()
|
434 | };
|
435 | mountedMap.set(atom, mounted);
|
436 | {
|
437 | mountedAtoms.add(atom);
|
438 | }
|
439 | const atomState = readAtomState(void 0, atom);
|
440 | atomState.d.forEach((_, a) => {
|
441 | const aMounted = mountedMap.get(a);
|
442 | if (aMounted) {
|
443 | aMounted.t.add(atom);
|
444 | } else {
|
445 | if (a !== atom) {
|
446 | mountAtom(a, atom);
|
447 | }
|
448 | }
|
449 | });
|
450 | if (isActuallyWritableAtom(atom) && atom.onMount) {
|
451 | const setAtom = (update) => writeAtom(atom, update);
|
452 | const onUnmount = atom.onMount(setAtom);
|
453 | if (onUnmount) {
|
454 | mounted.u = onUnmount;
|
455 | }
|
456 | }
|
457 | return mounted;
|
458 | };
|
459 | const unmountAtom = (atom) => {
|
460 | var _a;
|
461 | const onUnmount = (_a = mountedMap.get(atom)) == null ? void 0 : _a.u;
|
462 | if (onUnmount) {
|
463 | onUnmount();
|
464 | }
|
465 | mountedMap.delete(atom);
|
466 | {
|
467 | mountedAtoms.delete(atom);
|
468 | }
|
469 | const atomState = getAtomState(void 0, atom);
|
470 | if (atomState) {
|
471 | atomState.d.forEach((_, a) => {
|
472 | if (a !== atom) {
|
473 | const mounted = mountedMap.get(a);
|
474 | if (mounted) {
|
475 | mounted.t.delete(atom);
|
476 | if (canUnmountAtom(a, mounted)) {
|
477 | unmountAtom(a);
|
478 | }
|
479 | }
|
480 | }
|
481 | });
|
482 | } else {
|
483 | console.warn("[Bug] could not find atom state to unmount", atom);
|
484 | }
|
485 | };
|
486 | const mountDependencies = (atom, atomState, prevReadDependencies) => {
|
487 | const dependencies = new Set(atomState.d.keys());
|
488 | prevReadDependencies == null ? void 0 : prevReadDependencies.forEach((_, a) => {
|
489 | if (dependencies.has(a)) {
|
490 | dependencies.delete(a);
|
491 | return;
|
492 | }
|
493 | const mounted = mountedMap.get(a);
|
494 | if (mounted) {
|
495 | mounted.t.delete(atom);
|
496 | if (canUnmountAtom(a, mounted)) {
|
497 | unmountAtom(a);
|
498 | }
|
499 | }
|
500 | });
|
501 | dependencies.forEach((a) => {
|
502 | const mounted = mountedMap.get(a);
|
503 | if (mounted) {
|
504 | mounted.t.add(atom);
|
505 | } else if (mountedMap.has(atom)) {
|
506 | mountAtom(a, atom);
|
507 | }
|
508 | });
|
509 | };
|
510 | const flushPending = (version) => {
|
511 | if (version) {
|
512 | const versionedAtomStateMap = getVersionedAtomStateMap(version);
|
513 | versionedAtomStateMap.forEach((atomState, atom) => {
|
514 | if (atomState !== committedAtomStateMap.get(atom)) {
|
515 | const mounted = mountedMap.get(atom);
|
516 | mounted == null ? void 0 : mounted.l.forEach((listener) => listener(version));
|
517 | }
|
518 | });
|
519 | return;
|
520 | }
|
521 | while (pendingMap.size) {
|
522 | const pending = Array.from(pendingMap);
|
523 | pendingMap.clear();
|
524 | pending.forEach(([atom, prevAtomState]) => {
|
525 | const atomState = getAtomState(void 0, atom);
|
526 | if (atomState && atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {
|
527 | mountDependencies(atom, atomState, prevAtomState == null ? void 0 : prevAtomState.d);
|
528 | }
|
529 | const mounted = mountedMap.get(atom);
|
530 | mounted == null ? void 0 : mounted.l.forEach((listener) => listener());
|
531 | });
|
532 | }
|
533 | {
|
534 | stateListeners.forEach((l) => l());
|
535 | }
|
536 | };
|
537 | const commitVersionedAtomStateMap = (version) => {
|
538 | const versionedAtomStateMap = getVersionedAtomStateMap(version);
|
539 | versionedAtomStateMap.forEach((atomState, atom) => {
|
540 | const prevAtomState = committedAtomStateMap.get(atom);
|
541 | if (atomState.r > ((prevAtomState == null ? void 0 : prevAtomState.r) || 0) || "v" in atomState && atomState.r === (prevAtomState == null ? void 0 : prevAtomState.r) && atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {
|
542 | committedAtomStateMap.set(atom, atomState);
|
543 | if (atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {
|
544 | mountDependencies(atom, atomState, prevAtomState == null ? void 0 : prevAtomState.d);
|
545 | }
|
546 | }
|
547 | });
|
548 | };
|
549 | const commitAtom = (_atom, version) => {
|
550 | if (version) {
|
551 | commitVersionedAtomStateMap(version);
|
552 | }
|
553 | flushPending(void 0);
|
554 | };
|
555 | const subscribeAtom = (atom, callback) => {
|
556 | const mounted = addAtom(atom);
|
557 | const listeners = mounted.l;
|
558 | listeners.add(callback);
|
559 | return () => {
|
560 | listeners.delete(callback);
|
561 | delAtom(atom);
|
562 | };
|
563 | };
|
564 | const restoreAtoms = (values, version) => {
|
565 | for (const [atom, value] of values) {
|
566 | if (hasInitialValue(atom)) {
|
567 | setAtomPromiseOrValue(version, atom, value);
|
568 | invalidateDependents(version, atom);
|
569 | }
|
570 | }
|
571 | flushPending(version);
|
572 | };
|
573 | {
|
574 | return {
|
575 | [READ_ATOM]: readAtom,
|
576 | [WRITE_ATOM]: writeAtom,
|
577 | [COMMIT_ATOM]: commitAtom,
|
578 | [SUBSCRIBE_ATOM]: subscribeAtom,
|
579 | [RESTORE_ATOMS]: restoreAtoms,
|
580 | [DEV_SUBSCRIBE_STATE]: (l) => {
|
581 | stateListeners.add(l);
|
582 | return () => {
|
583 | stateListeners.delete(l);
|
584 | };
|
585 | },
|
586 | [DEV_GET_MOUNTED_ATOMS]: () => mountedAtoms.values(),
|
587 | [DEV_GET_ATOM_STATE]: (a) => committedAtomStateMap.get(a),
|
588 | [DEV_GET_MOUNTED]: (a) => mountedMap.get(a)
|
589 | };
|
590 | }
|
591 | };
|
592 | const createStoreForExport = exports('unstable_createStore', (initialValues) => {
|
593 | const store = createStore(initialValues);
|
594 | const get = (atom) => {
|
595 | const atomState = store[READ_ATOM](atom);
|
596 | if ("e" in atomState) {
|
597 | throw atomState.e;
|
598 | }
|
599 | if ("p" in atomState) {
|
600 | return void 0;
|
601 | }
|
602 | return atomState.v;
|
603 | };
|
604 | const asyncGet = (atom) => new Promise((resolve, reject) => {
|
605 | const atomState = store[READ_ATOM](atom);
|
606 | if ("e" in atomState) {
|
607 | reject(atomState.e);
|
608 | } else if ("p" in atomState) {
|
609 | resolve(atomState.p.then(() => asyncGet(atom)));
|
610 | } else {
|
611 | resolve(atomState.v);
|
612 | }
|
613 | });
|
614 | const set = (atom, update) => store[WRITE_ATOM](atom, update);
|
615 | const sub = (atom, callback) => store[SUBSCRIBE_ATOM](atom, callback);
|
616 | return {
|
617 | get,
|
618 | asyncGet,
|
619 | set,
|
620 | sub,
|
621 | SECRET_INTERNAL_store: store
|
622 | };
|
623 | });
|
624 |
|
625 | const createScopeContainer = (initialValues, unstable_createStore) => {
|
626 | const store = unstable_createStore ? unstable_createStore(initialValues).SECRET_INTERNAL_store : createStore(initialValues);
|
627 | return { s: store };
|
628 | };
|
629 | const ScopeContextMap = new Map();
|
630 | const getScopeContext = exports('SECRET_INTERNAL_getScopeContext', (scope) => {
|
631 | if (!ScopeContextMap.has(scope)) {
|
632 | ScopeContextMap.set(scope, createContext(createScopeContainer()));
|
633 | }
|
634 | return ScopeContextMap.get(scope);
|
635 | });
|
636 |
|
637 | var __defProp = Object.defineProperty;
|
638 | var __defProps = Object.defineProperties;
|
639 | var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
|
640 | var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
641 | var __hasOwnProp = Object.prototype.hasOwnProperty;
|
642 | var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
643 | var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
644 | var __spreadValues = (a, b) => {
|
645 | for (var prop in b || (b = {}))
|
646 | if (__hasOwnProp.call(b, prop))
|
647 | __defNormalProp(a, prop, b[prop]);
|
648 | if (__getOwnPropSymbols)
|
649 | for (var prop of __getOwnPropSymbols(b)) {
|
650 | if (__propIsEnum.call(b, prop))
|
651 | __defNormalProp(a, prop, b[prop]);
|
652 | }
|
653 | return a;
|
654 | };
|
655 | var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
|
656 | const atomToPrintable = (atom) => atom.debugLabel || atom.toString();
|
657 | const stateToPrintable = ([store, atoms]) => Object.fromEntries(atoms.flatMap((atom) => {
|
658 | var _a, _b;
|
659 | const mounted = (_a = store[DEV_GET_MOUNTED]) == null ? void 0 : _a.call(store, atom);
|
660 | if (!mounted) {
|
661 | return [];
|
662 | }
|
663 | const dependents = mounted.t;
|
664 | const atomState = ((_b = store[DEV_GET_ATOM_STATE]) == null ? void 0 : _b.call(store, atom)) || {};
|
665 | return [
|
666 | [
|
667 | atomToPrintable(atom),
|
668 | __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, "e" in atomState && { error: atomState.e }), "p" in atomState && { promise: atomState.p }), "v" in atomState && { value: atomState.v }), {
|
669 | dependents: Array.from(dependents).map(atomToPrintable)
|
670 | })
|
671 | ]
|
672 | ];
|
673 | }));
|
674 | const useDebugState = (scopeContainer) => {
|
675 | const { s: store } = scopeContainer;
|
676 | const [atoms, setAtoms] = useState([]);
|
677 | useEffect(() => {
|
678 | var _a;
|
679 | const callback = () => {
|
680 | var _a2;
|
681 | setAtoms(Array.from(((_a2 = store[DEV_GET_MOUNTED_ATOMS]) == null ? void 0 : _a2.call(store)) || []));
|
682 | };
|
683 | const unsubscribe = (_a = store[DEV_SUBSCRIBE_STATE]) == null ? void 0 : _a.call(store, callback);
|
684 | callback();
|
685 | return unsubscribe;
|
686 | }, [store]);
|
687 | useDebugValue([store, atoms], stateToPrintable);
|
688 | };
|
689 |
|
690 | const Provider = exports('Provider', ({
|
691 | children,
|
692 | initialValues,
|
693 | scope,
|
694 | unstable_createStore,
|
695 | unstable_enableVersionedWrite
|
696 | }) => {
|
697 | const [version, setVersion] = useState();
|
698 | useEffect(() => {
|
699 | if (version) {
|
700 | scopeContainerRef.current.s[COMMIT_ATOM](null, version);
|
701 | delete version.p;
|
702 | }
|
703 | }, [version]);
|
704 | const scopeContainerRef = useRef();
|
705 | if (!scopeContainerRef.current) {
|
706 | scopeContainerRef.current = createScopeContainer(initialValues, unstable_createStore);
|
707 | if (unstable_enableVersionedWrite) {
|
708 | scopeContainerRef.current.w = (write) => {
|
709 | setVersion((parentVersion) => {
|
710 | const nextVersion = parentVersion ? { p: parentVersion } : {};
|
711 | write(nextVersion);
|
712 | return nextVersion;
|
713 | });
|
714 | };
|
715 | }
|
716 | }
|
717 | if (!unstable_enableVersionedWrite) {
|
718 | useDebugState(scopeContainerRef.current);
|
719 | }
|
720 | const ScopeContainerContext = getScopeContext(scope);
|
721 | return createElement(ScopeContainerContext.Provider, {
|
722 | value: scopeContainerRef.current
|
723 | }, children);
|
724 | });
|
725 |
|
726 | let keyCount = 0;
|
727 | function atom(read, write) {
|
728 | const key = `atom${++keyCount}`;
|
729 | const config = {
|
730 | toString: () => key
|
731 | };
|
732 | if (typeof read === "function") {
|
733 | config.read = read;
|
734 | } else {
|
735 | config.init = read;
|
736 | config.read = (get) => get(config);
|
737 | config.write = (get, set, update) => set(config, typeof update === "function" ? update(get(config)) : update);
|
738 | }
|
739 | if (write) {
|
740 | config.write = write;
|
741 | }
|
742 | return config;
|
743 | }
|
744 |
|
745 | function useAtomValue(atom, scope) {
|
746 | const ScopeContext = getScopeContext(scope);
|
747 | const { s: store } = useContext(ScopeContext);
|
748 | const getAtomValue = useCallback((version2) => {
|
749 | const atomState = store[READ_ATOM](atom, version2);
|
750 | if ("e" in atomState) {
|
751 | throw atomState.e;
|
752 | }
|
753 | if ("p" in atomState) {
|
754 | throw atomState.p;
|
755 | }
|
756 | if ("v" in atomState) {
|
757 | return atomState.v;
|
758 | }
|
759 | throw new Error("no atom value");
|
760 | }, [store, atom]);
|
761 | const [[version, value, atomFromUseReducer], rerenderIfChanged] = useReducer(useCallback((prev, nextVersion) => {
|
762 | const nextValue = getAtomValue(nextVersion);
|
763 | if (Object.is(prev[1], nextValue) && prev[2] === atom) {
|
764 | return prev;
|
765 | }
|
766 | return [nextVersion, nextValue, atom];
|
767 | }, [getAtomValue, atom]), void 0, () => {
|
768 | const initialVersion = void 0;
|
769 | const initialValue = getAtomValue(initialVersion);
|
770 | return [initialVersion, initialValue, atom];
|
771 | });
|
772 | if (atomFromUseReducer !== atom) {
|
773 | rerenderIfChanged(void 0);
|
774 | }
|
775 | useEffect(() => {
|
776 | const unsubscribe = store[SUBSCRIBE_ATOM](atom, rerenderIfChanged);
|
777 | rerenderIfChanged(void 0);
|
778 | return unsubscribe;
|
779 | }, [store, atom]);
|
780 | useEffect(() => {
|
781 | store[COMMIT_ATOM](atom, version);
|
782 | });
|
783 | useDebugValue(value);
|
784 | return value;
|
785 | }
|
786 |
|
787 | function useSetAtom(atom, scope) {
|
788 | const ScopeContext = getScopeContext(scope);
|
789 | const { s: store, w: versionedWrite } = useContext(ScopeContext);
|
790 | const setAtom = useCallback((update) => {
|
791 | if (!("write" in atom)) {
|
792 | throw new Error("not writable atom");
|
793 | }
|
794 | const write = (version) => store[WRITE_ATOM](atom, update, version);
|
795 | return versionedWrite ? versionedWrite(write) : write();
|
796 | }, [store, versionedWrite, atom]);
|
797 | return setAtom;
|
798 | }
|
799 |
|
800 | function useAtom(atom, scope) {
|
801 | if ("scope" in atom) {
|
802 | console.warn("atom.scope is deprecated. Please do useAtom(atom, scope) instead.");
|
803 | scope = atom.scope;
|
804 | }
|
805 | return [
|
806 | useAtomValue(atom, scope),
|
807 | useSetAtom(atom, scope)
|
808 | ];
|
809 | }
|
810 |
|
811 | })
|
812 | };
|
813 | }));
|