1 | 'use strict';
|
2 |
|
3 | var queryCore = require('@tanstack/query-core');
|
4 | var jotai = require('jotai');
|
5 |
|
6 | var queryClientAtom = jotai.atom(new queryCore.QueryClient());
|
7 |
|
8 | function atomWithQuery(createQuery, getQueryClient) {
|
9 | if (getQueryClient === void 0) {
|
10 | getQueryClient = function getQueryClient(get) {
|
11 | return get(queryClientAtom);
|
12 | };
|
13 | }
|
14 | var previousDataCache = new WeakMap();
|
15 | var queryDataAtom = jotai.atom(function (get) {
|
16 | var queryClient = getQueryClient(get);
|
17 | var options = typeof createQuery === 'function' ? createQuery(get) : createQuery;
|
18 | var observer = new queryCore.QueryObserver(queryClient, options);
|
19 | var initialResult = observer.getCurrentResult();
|
20 | if (initialResult.data === undefined && options.keepPreviousData && previousDataCache.has(queryClient)) {
|
21 | initialResult.data = previousDataCache.get(queryClient);
|
22 | }
|
23 | var resolve = null;
|
24 | var makePending = function makePending() {
|
25 | return new Promise(function (r) {
|
26 | resolve = r;
|
27 | });
|
28 | };
|
29 | var resultAtom = jotai.atom(initialResult.data === undefined && options.enabled !== false ? makePending() : initialResult);
|
30 | var setResult = null;
|
31 | var listener = function listener(result) {
|
32 | if (result.isFetching || !result.isError && result.data === undefined) {
|
33 | return;
|
34 | }
|
35 | if (!resolve && !setResult) {
|
36 | throw new Error('setting result without mount');
|
37 | }
|
38 | if (resolve) {
|
39 | resolve(result);
|
40 | resolve = null;
|
41 | }
|
42 | if (setResult) {
|
43 | setResult(result);
|
44 | }
|
45 | if (result.data !== undefined) {
|
46 | previousDataCache.set(queryClient, result.data);
|
47 | }
|
48 | };
|
49 | var unsubscribe = null;
|
50 | var timer;
|
51 | var startQuery = function startQuery() {
|
52 | if (!setResult && unsubscribe) {
|
53 | clearTimeout(timer);
|
54 | unsubscribe();
|
55 | unsubscribe = null;
|
56 | }
|
57 | if (options.enabled !== false) {
|
58 | if (setResult) {
|
59 | observer.refetch({
|
60 | cancelRefetch: true
|
61 | }).then(setResult);
|
62 | } else {
|
63 | unsubscribe = observer.subscribe(listener);
|
64 | }
|
65 | }
|
66 | if (!setResult) {
|
67 | timer = setTimeout(function () {
|
68 | if (unsubscribe) {
|
69 | unsubscribe();
|
70 | unsubscribe = null;
|
71 | }
|
72 | }, 1000);
|
73 | }
|
74 | };
|
75 | startQuery();
|
76 | resultAtom.onMount = function (update) {
|
77 | setResult = update;
|
78 | if (unsubscribe) {
|
79 | clearTimeout(timer);
|
80 | } else {
|
81 | startQuery();
|
82 | }
|
83 | return function () {
|
84 | setResult = null;
|
85 | if (unsubscribe) {
|
86 | unsubscribe();
|
87 | }
|
88 | };
|
89 | };
|
90 |
|
91 | return {
|
92 | resultAtom: resultAtom,
|
93 | makePending: makePending,
|
94 | startQuery: startQuery
|
95 | };
|
96 | });
|
97 | var queryAtom = jotai.atom(function (get) {
|
98 | var _get = get(queryDataAtom),
|
99 | resultAtom = _get.resultAtom;
|
100 | var result = get(resultAtom);
|
101 | if (result.isError) {
|
102 | throw result.error;
|
103 | }
|
104 | return result.data;
|
105 | }, function (get, set, action) {
|
106 | var _get2 = get(queryDataAtom),
|
107 | resultAtom = _get2.resultAtom,
|
108 | makePending = _get2.makePending,
|
109 | startQuery = _get2.startQuery;
|
110 | switch (action.type) {
|
111 | case 'refetch':
|
112 | {
|
113 | set(resultAtom, makePending());
|
114 | startQuery();
|
115 | }
|
116 | }
|
117 | });
|
118 | return queryAtom;
|
119 | }
|
120 |
|
121 | function atomWithInfiniteQuery(createQuery, getQueryClient) {
|
122 | if (getQueryClient === void 0) {
|
123 | getQueryClient = function getQueryClient(get) {
|
124 | return get(queryClientAtom);
|
125 | };
|
126 | }
|
127 | var queryDataAtom = jotai.atom(function (get) {
|
128 | var queryClient = getQueryClient(get);
|
129 | var options = typeof createQuery === 'function' ? createQuery(get) : createQuery;
|
130 | var defaultedOptions = queryClient.defaultQueryOptions(options);
|
131 | var observer = new queryCore.InfiniteQueryObserver(queryClient, defaultedOptions);
|
132 | var initialResult = observer.getCurrentResult();
|
133 | var resolve = null;
|
134 | var resultAtom = jotai.atom(initialResult.data === undefined && options.enabled !== false ? new Promise(function (r) {
|
135 | resolve = r;
|
136 | }) : initialResult);
|
137 | var setResult = function setResult() {
|
138 | throw new Error('setting result without mount');
|
139 | };
|
140 | var state = {
|
141 | isMounted: false,
|
142 | unsubscribe: null
|
143 | };
|
144 | var listener = function listener(result) {
|
145 | if (result.isFetching || !result.isError && result.data === undefined || result.isError && queryCore.isCancelledError(result.error)) {
|
146 | return;
|
147 | }
|
148 | if (resolve) {
|
149 | setTimeout(function () {
|
150 | if (!state.isMounted) {
|
151 | state.unsubscribe == null ? void 0 : state.unsubscribe();
|
152 | state.unsubscribe = null;
|
153 | }
|
154 | }, 1000);
|
155 | resolve(result);
|
156 | resolve = null;
|
157 | } else {
|
158 | setResult(result);
|
159 | }
|
160 | };
|
161 | if (options.enabled !== false) {
|
162 | state.unsubscribe = observer.subscribe(listener);
|
163 | }
|
164 | resultAtom.onMount = function (update) {
|
165 | setResult = update;
|
166 | state.isMounted = true;
|
167 | if (options.enabled !== false && !state.unsubscribe) {
|
168 | state.unsubscribe = observer.subscribe(listener);
|
169 | listener(observer.getCurrentResult());
|
170 | }
|
171 | return function () {
|
172 | return state.unsubscribe == null ? void 0 : state.unsubscribe();
|
173 | };
|
174 | };
|
175 | return {
|
176 | options: options,
|
177 | resultAtom: resultAtom,
|
178 | observer: observer,
|
179 | state: state
|
180 | };
|
181 | }, function (get, set, action) {
|
182 | var _get2 = get(queryDataAtom),
|
183 | options = _get2.options,
|
184 | resultAtom = _get2.resultAtom,
|
185 | observer = _get2.observer,
|
186 | state = _get2.state;
|
187 | if (options.enabled === false) {
|
188 | return;
|
189 | }
|
190 | switch (action.type) {
|
191 | case 'refetch':
|
192 | {
|
193 | set(resultAtom, new Promise(function () {}));
|
194 | if (!state.isMounted) {
|
195 | state.unsubscribe == null ? void 0 : state.unsubscribe();
|
196 | state.unsubscribe = null;
|
197 | }
|
198 | observer.refetch(action.payload).then(function (result) {
|
199 | set(resultAtom, result);
|
200 | });
|
201 | return;
|
202 | }
|
203 | case 'fetchPreviousPage':
|
204 | {
|
205 | observer.fetchPreviousPage();
|
206 | return;
|
207 | }
|
208 | case 'fetchNextPage':
|
209 | {
|
210 | observer.fetchNextPage();
|
211 | return;
|
212 | }
|
213 | }
|
214 | });
|
215 | var queryAtom = jotai.atom(function (get) {
|
216 | var _get3 = get(queryDataAtom),
|
217 | resultAtom = _get3.resultAtom;
|
218 | var result = get(resultAtom);
|
219 | if (result.isError) {
|
220 | throw result.error;
|
221 | }
|
222 | return result.data;
|
223 | }, function (_get, set, action) {
|
224 | return set(queryDataAtom, action);
|
225 | });
|
226 |
|
227 | return queryAtom;
|
228 | }
|
229 |
|
230 | exports.atomWithInfiniteQuery = atomWithInfiniteQuery;
|
231 | exports.atomWithQuery = atomWithQuery;
|
232 | exports.queryClientAtom = queryClientAtom;
|