node_modules ignore

server/node_modules/react-query/lib/react/Hydrate.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.useHydrate = useHydrate;
+exports.Hydrate = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _core = require("../core");
+
+var _QueryClientProvider = require("./QueryClientProvider");
+
+function useHydrate(state, options) {
+  var queryClient = (0, _QueryClientProvider.useQueryClient)();
+
+  var optionsRef = _react.default.useRef(options);
+
+  optionsRef.current = options; // Running hydrate again with the same queries is safe,
+  // it wont overwrite or initialize existing queries,
+  // relying on useMemo here is only a performance optimization.
+  // hydrate can and should be run *during* render here for SSR to work properly
+
+  _react.default.useMemo(function () {
+    if (state) {
+      (0, _core.hydrate)(queryClient, state, optionsRef.current);
+    }
+  }, [queryClient, state]);
+}
+
+var Hydrate = function Hydrate(_ref) {
+  var children = _ref.children,
+      options = _ref.options,
+      state = _ref.state;
+  useHydrate(state, options);
+  return children;
+};
+
+exports.Hydrate = Hydrate;

server/node_modules/react-query/lib/react/QueryClientProvider.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.QueryClientProvider = exports.useQueryClient = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var defaultContext = /*#__PURE__*/_react.default.createContext(undefined);
+
+var QueryClientSharingContext = /*#__PURE__*/_react.default.createContext(false); // if contextSharing is on, we share the first and at least one
+// instance of the context across the window
+// to ensure that if React Query is used across
+// different bundles or microfrontends they will
+// all use the same **instance** of context, regardless
+// of module scoping.
+
+
+function getQueryClientContext(contextSharing) {
+  if (contextSharing && typeof window !== 'undefined') {
+    if (!window.ReactQueryClientContext) {
+      window.ReactQueryClientContext = defaultContext;
+    }
+
+    return window.ReactQueryClientContext;
+  }
+
+  return defaultContext;
+}
+
+var useQueryClient = function useQueryClient() {
+  var queryClient = _react.default.useContext(getQueryClientContext(_react.default.useContext(QueryClientSharingContext)));
+
+  if (!queryClient) {
+    throw new Error('No QueryClient set, use QueryClientProvider to set one');
+  }
+
+  return queryClient;
+};
+
+exports.useQueryClient = useQueryClient;
+
+var QueryClientProvider = function QueryClientProvider(_ref) {
+  var client = _ref.client,
+      _ref$contextSharing = _ref.contextSharing,
+      contextSharing = _ref$contextSharing === void 0 ? false : _ref$contextSharing,
+      children = _ref.children;
+
+  _react.default.useEffect(function () {
+    client.mount();
+    return function () {
+      client.unmount();
+    };
+  }, [client]);
+
+  var Context = getQueryClientContext(contextSharing);
+  return /*#__PURE__*/_react.default.createElement(QueryClientSharingContext.Provider, {
+    value: contextSharing
+  }, /*#__PURE__*/_react.default.createElement(Context.Provider, {
+    value: client
+  }, children));
+};
+
+exports.QueryClientProvider = QueryClientProvider;

server/node_modules/react-query/lib/react/QueryErrorResetBoundary.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.QueryErrorResetBoundary = exports.useQueryErrorResetBoundary = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+function createValue() {
+  var _isReset = false;
+  return {
+    clearReset: function clearReset() {
+      _isReset = false;
+    },
+    reset: function reset() {
+      _isReset = true;
+    },
+    isReset: function isReset() {
+      return _isReset;
+    }
+  };
+}
+
+var QueryErrorResetBoundaryContext = /*#__PURE__*/_react.default.createContext(createValue()); // HOOK
+
+
+var useQueryErrorResetBoundary = function useQueryErrorResetBoundary() {
+  return _react.default.useContext(QueryErrorResetBoundaryContext);
+}; // COMPONENT
+
+
+exports.useQueryErrorResetBoundary = useQueryErrorResetBoundary;
+
+var QueryErrorResetBoundary = function QueryErrorResetBoundary(_ref) {
+  var children = _ref.children;
+
+  var value = _react.default.useMemo(function () {
+    return createValue();
+  }, []);
+
+  return /*#__PURE__*/_react.default.createElement(QueryErrorResetBoundaryContext.Provider, {
+    value: value
+  }, typeof children === 'function' ? children(value) : children);
+};
+
+exports.QueryErrorResetBoundary = QueryErrorResetBoundary;

server/node_modules/react-query/lib/react/index.js

@@ -0,0 +1,69 @@
+"use strict";
+
+exports.__esModule = true;
+var _exportNames = {
+  QueryClientProvider: true,
+  useQueryClient: true,
+  QueryErrorResetBoundary: true,
+  useQueryErrorResetBoundary: true,
+  useIsFetching: true,
+  useIsMutating: true,
+  useMutation: true,
+  useQuery: true,
+  useQueries: true,
+  useInfiniteQuery: true,
+  useHydrate: true,
+  Hydrate: true
+};
+exports.Hydrate = exports.useHydrate = exports.useInfiniteQuery = exports.useQueries = exports.useQuery = exports.useMutation = exports.useIsMutating = exports.useIsFetching = exports.useQueryErrorResetBoundary = exports.QueryErrorResetBoundary = exports.useQueryClient = exports.QueryClientProvider = void 0;
+
+require("./setBatchUpdatesFn");
+
+require("./setLogger");
+
+var _QueryClientProvider = require("./QueryClientProvider");
+
+exports.QueryClientProvider = _QueryClientProvider.QueryClientProvider;
+exports.useQueryClient = _QueryClientProvider.useQueryClient;
+
+var _QueryErrorResetBoundary = require("./QueryErrorResetBoundary");
+
+exports.QueryErrorResetBoundary = _QueryErrorResetBoundary.QueryErrorResetBoundary;
+exports.useQueryErrorResetBoundary = _QueryErrorResetBoundary.useQueryErrorResetBoundary;
+
+var _useIsFetching = require("./useIsFetching");
+
+exports.useIsFetching = _useIsFetching.useIsFetching;
+
+var _useIsMutating = require("./useIsMutating");
+
+exports.useIsMutating = _useIsMutating.useIsMutating;
+
+var _useMutation = require("./useMutation");
+
+exports.useMutation = _useMutation.useMutation;
+
+var _useQuery = require("./useQuery");
+
+exports.useQuery = _useQuery.useQuery;
+
+var _useQueries = require("./useQueries");
+
+exports.useQueries = _useQueries.useQueries;
+
+var _useInfiniteQuery = require("./useInfiniteQuery");
+
+exports.useInfiniteQuery = _useInfiniteQuery.useInfiniteQuery;
+
+var _Hydrate = require("./Hydrate");
+
+exports.useHydrate = _Hydrate.useHydrate;
+exports.Hydrate = _Hydrate.Hydrate;
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  exports[key] = _types[key];
+});

server/node_modules/react-query/lib/react/logger.js

@@ -0,0 +1,6 @@
+"use strict";
+
+exports.__esModule = true;
+exports.logger = void 0;
+var logger = console;
+exports.logger = logger;

server/node_modules/react-query/lib/react/logger.native.js

@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports.logger = void 0;
+var logger = {
+  log: console.log,
+  warn: console.warn,
+  error: console.warn
+};
+exports.logger = logger;

server/node_modules/react-query/lib/react/reactBatchedUpdates.js

@@ -0,0 +1,11 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.unstable_batchedUpdates = void 0;
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var unstable_batchedUpdates = _reactDom.default.unstable_batchedUpdates;
+exports.unstable_batchedUpdates = unstable_batchedUpdates;

server/node_modules/react-query/lib/react/reactBatchedUpdates.native.js

@@ -0,0 +1,7 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _reactNative = require("react-native");
+
+exports.unstable_batchedUpdates = _reactNative.unstable_batchedUpdates;

server/node_modules/react-query/lib/react/setBatchUpdatesFn.js

@@ -0,0 +1,7 @@
+"use strict";
+
+var _core = require("../core");
+
+var _reactBatchedUpdates = require("./reactBatchedUpdates");
+
+_core.notifyManager.setBatchNotifyFunction(_reactBatchedUpdates.unstable_batchedUpdates);

server/node_modules/react-query/lib/react/setLogger.js

@@ -0,0 +1,7 @@
+"use strict";
+
+var _core = require("../core");
+
+var _logger = require("./logger");
+
+(0, _core.setLogger)(_logger.logger);

server/node_modules/react-query/lib/react/types.js

@@ -0,0 +1 @@
+"use strict";

server/node_modules/react-query/lib/react/useBaseQuery.js

@@ -0,0 +1,121 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.useBaseQuery = useBaseQuery;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _notifyManager = require("../core/notifyManager");
+
+var _QueryErrorResetBoundary = require("./QueryErrorResetBoundary");
+
+var _QueryClientProvider = require("./QueryClientProvider");
+
+var _utils = require("./utils");
+
+function useBaseQuery(options, Observer) {
+  var mountedRef = _react.default.useRef(false);
+
+  var _React$useState = _react.default.useState(0),
+      forceUpdate = _React$useState[1];
+
+  var queryClient = (0, _QueryClientProvider.useQueryClient)();
+  var errorResetBoundary = (0, _QueryErrorResetBoundary.useQueryErrorResetBoundary)();
+  var defaultedOptions = queryClient.defaultQueryObserverOptions(options); // Make sure results are optimistically set in fetching state before subscribing or updating options
+
+  defaultedOptions.optimisticResults = true; // Include callbacks in batch renders
+
+  if (defaultedOptions.onError) {
+    defaultedOptions.onError = _notifyManager.notifyManager.batchCalls(defaultedOptions.onError);
+  }
+
+  if (defaultedOptions.onSuccess) {
+    defaultedOptions.onSuccess = _notifyManager.notifyManager.batchCalls(defaultedOptions.onSuccess);
+  }
+
+  if (defaultedOptions.onSettled) {
+    defaultedOptions.onSettled = _notifyManager.notifyManager.batchCalls(defaultedOptions.onSettled);
+  }
+
+  if (defaultedOptions.suspense) {
+    // Always set stale time when using suspense to prevent
+    // fetching again when directly mounting after suspending
+    if (typeof defaultedOptions.staleTime !== 'number') {
+      defaultedOptions.staleTime = 1000;
+    } // Set cache time to 1 if the option has been set to 0
+    // when using suspense to prevent infinite loop of fetches
+
+
+    if (defaultedOptions.cacheTime === 0) {
+      defaultedOptions.cacheTime = 1;
+    }
+  }
+
+  if (defaultedOptions.suspense || defaultedOptions.useErrorBoundary) {
+    // Prevent retrying failed query if the error boundary has not been reset yet
+    if (!errorResetBoundary.isReset()) {
+      defaultedOptions.retryOnMount = false;
+    }
+  }
+
+  var _React$useState2 = _react.default.useState(function () {
+    return new Observer(queryClient, defaultedOptions);
+  }),
+      observer = _React$useState2[0];
+
+  var result = observer.getOptimisticResult(defaultedOptions);
+
+  _react.default.useEffect(function () {
+    mountedRef.current = true;
+    errorResetBoundary.clearReset();
+    var unsubscribe = observer.subscribe(_notifyManager.notifyManager.batchCalls(function () {
+      if (mountedRef.current) {
+        forceUpdate(function (x) {
+          return x + 1;
+        });
+      }
+    })); // Update result to make sure we did not miss any query updates
+    // between creating the observer and subscribing to it.
+
+    observer.updateResult();
+    return function () {
+      mountedRef.current = false;
+      unsubscribe();
+    };
+  }, [errorResetBoundary, observer]);
+
+  _react.default.useEffect(function () {
+    // Do not notify on updates because of changes in the options because
+    // these changes should already be reflected in the optimistic result.
+    observer.setOptions(defaultedOptions, {
+      listeners: false
+    });
+  }, [defaultedOptions, observer]); // Handle suspense
+
+
+  if (defaultedOptions.suspense && result.isLoading) {
+    throw observer.fetchOptimistic(defaultedOptions).then(function (_ref) {
+      var data = _ref.data;
+      defaultedOptions.onSuccess == null ? void 0 : defaultedOptions.onSuccess(data);
+      defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(data, null);
+    }).catch(function (error) {
+      errorResetBoundary.clearReset();
+      defaultedOptions.onError == null ? void 0 : defaultedOptions.onError(error);
+      defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(undefined, error);
+    });
+  } // Handle error boundary
+
+
+  if (result.isError && !errorResetBoundary.isReset() && !result.isFetching && (0, _utils.shouldThrowError)(defaultedOptions.suspense, defaultedOptions.useErrorBoundary, [result.error, observer.getCurrentQuery()])) {
+    throw result.error;
+  } // Handle result property usage tracking
+
+
+  if (defaultedOptions.notifyOnChangeProps === 'tracked') {
+    result = observer.trackResult(result, defaultedOptions);
+  }
+
+  return result;
+}

server/node_modules/react-query/lib/react/useInfiniteQuery.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+exports.useInfiniteQuery = useInfiniteQuery;
+
+var _infiniteQueryObserver = require("../core/infiniteQueryObserver");
+
+var _utils = require("../core/utils");
+
+var _useBaseQuery = require("./useBaseQuery");
+
+function useInfiniteQuery(arg1, arg2, arg3) {
+  var options = (0, _utils.parseQueryArgs)(arg1, arg2, arg3);
+  return (0, _useBaseQuery.useBaseQuery)(options, _infiniteQueryObserver.InfiniteQueryObserver);
+}

server/node_modules/react-query/lib/react/useIsFetching.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.useIsFetching = useIsFetching;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _notifyManager = require("../core/notifyManager");
+
+var _utils = require("../core/utils");
+
+var _QueryClientProvider = require("./QueryClientProvider");
+
+var checkIsFetching = function checkIsFetching(queryClient, filters, isFetching, setIsFetching) {
+  var newIsFetching = queryClient.isFetching(filters);
+
+  if (isFetching !== newIsFetching) {
+    setIsFetching(newIsFetching);
+  }
+};
+
+function useIsFetching(arg1, arg2) {
+  var mountedRef = _react.default.useRef(false);
+
+  var queryClient = (0, _QueryClientProvider.useQueryClient)();
+
+  var _parseFilterArgs = (0, _utils.parseFilterArgs)(arg1, arg2),
+      filters = _parseFilterArgs[0];
+
+  var _React$useState = _react.default.useState(queryClient.isFetching(filters)),
+      isFetching = _React$useState[0],
+      setIsFetching = _React$useState[1];
+
+  var filtersRef = _react.default.useRef(filters);
+
+  filtersRef.current = filters;
+
+  var isFetchingRef = _react.default.useRef(isFetching);
+
+  isFetchingRef.current = isFetching;
+
+  _react.default.useEffect(function () {
+    mountedRef.current = true;
+    checkIsFetching(queryClient, filtersRef.current, isFetchingRef.current, setIsFetching);
+    var unsubscribe = queryClient.getQueryCache().subscribe(_notifyManager.notifyManager.batchCalls(function () {
+      if (mountedRef.current) {
+        checkIsFetching(queryClient, filtersRef.current, isFetchingRef.current, setIsFetching);
+      }
+    }));
+    return function () {
+      mountedRef.current = false;
+      unsubscribe();
+    };
+  }, [queryClient]);
+
+  return isFetching;
+}

server/node_modules/react-query/lib/react/useIsMutating.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.useIsMutating = useIsMutating;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _notifyManager = require("../core/notifyManager");
+
+var _utils = require("../core/utils");
+
+var _QueryClientProvider = require("./QueryClientProvider");
+
+function useIsMutating(arg1, arg2) {
+  var mountedRef = _react.default.useRef(false);
+
+  var filters = (0, _utils.parseMutationFilterArgs)(arg1, arg2);
+  var queryClient = (0, _QueryClientProvider.useQueryClient)();
+
+  var _React$useState = _react.default.useState(queryClient.isMutating(filters)),
+      isMutating = _React$useState[0],
+      setIsMutating = _React$useState[1];
+
+  var filtersRef = _react.default.useRef(filters);
+
+  filtersRef.current = filters;
+
+  var isMutatingRef = _react.default.useRef(isMutating);
+
+  isMutatingRef.current = isMutating;
+
+  _react.default.useEffect(function () {
+    mountedRef.current = true;
+    var unsubscribe = queryClient.getMutationCache().subscribe(_notifyManager.notifyManager.batchCalls(function () {
+      if (mountedRef.current) {
+        var newIsMutating = queryClient.isMutating(filtersRef.current);
+
+        if (isMutatingRef.current !== newIsMutating) {
+          setIsMutating(newIsMutating);
+        }
+      }
+    }));
+    return function () {
+      mountedRef.current = false;
+      unsubscribe();
+    };
+  }, [queryClient]);
+
+  return isMutating;
+}

server/node_modules/react-query/lib/react/useMutation.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.useMutation = useMutation;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _notifyManager = require("../core/notifyManager");
+
+var _utils = require("../core/utils");
+
+var _mutationObserver = require("../core/mutationObserver");
+
+var _QueryClientProvider = require("./QueryClientProvider");
+
+var _utils2 = require("./utils");
+
+function useMutation(arg1, arg2, arg3) {
+  var mountedRef = _react.default.useRef(false);
+
+  var _React$useState = _react.default.useState(0),
+      forceUpdate = _React$useState[1];
+
+  var options = (0, _utils.parseMutationArgs)(arg1, arg2, arg3);
+  var queryClient = (0, _QueryClientProvider.useQueryClient)();
+
+  var obsRef = _react.default.useRef();
+
+  if (!obsRef.current) {
+    obsRef.current = new _mutationObserver.MutationObserver(queryClient, options);
+  } else {
+    obsRef.current.setOptions(options);
+  }
+
+  var currentResult = obsRef.current.getCurrentResult();
+
+  _react.default.useEffect(function () {
+    mountedRef.current = true;
+    var unsubscribe = obsRef.current.subscribe(_notifyManager.notifyManager.batchCalls(function () {
+      if (mountedRef.current) {
+        forceUpdate(function (x) {
+          return x + 1;
+        });
+      }
+    }));
+    return function () {
+      mountedRef.current = false;
+      unsubscribe();
+    };
+  }, []);
+
+  var mutate = _react.default.useCallback(function (variables, mutateOptions) {
+    obsRef.current.mutate(variables, mutateOptions).catch(_utils.noop);
+  }, []);
+
+  if (currentResult.error && (0, _utils2.shouldThrowError)(undefined, obsRef.current.options.useErrorBoundary, [currentResult.error])) {
+    throw currentResult.error;
+  }
+
+  return (0, _extends2.default)({}, currentResult, {
+    mutate: mutate,
+    mutateAsync: currentResult.mutate
+  });
+}

server/node_modules/react-query/lib/react/useQueries.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+exports.__esModule = true;
+exports.useQueries = useQueries;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _notifyManager = require("../core/notifyManager");
+
+var _queriesObserver = require("../core/queriesObserver");
+
+var _QueryClientProvider = require("./QueryClientProvider");
+
+function useQueries(queries) {
+  var mountedRef = _react.default.useRef(false);
+
+  var _React$useState = _react.default.useState(0),
+      forceUpdate = _React$useState[1];
+
+  var queryClient = (0, _QueryClientProvider.useQueryClient)();
+  var defaultedQueries = (0, _react.useMemo)(function () {
+    return queries.map(function (options) {
+      var defaultedOptions = queryClient.defaultQueryObserverOptions(options); // Make sure the results are already in fetching state before subscribing or updating options
+
+      defaultedOptions.optimisticResults = true;
+      return defaultedOptions;
+    });
+  }, [queries, queryClient]);
+
+  var _React$useState2 = _react.default.useState(function () {
+    return new _queriesObserver.QueriesObserver(queryClient, defaultedQueries);
+  }),
+      observer = _React$useState2[0];
+
+  var result = observer.getOptimisticResult(defaultedQueries);
+
+  _react.default.useEffect(function () {
+    mountedRef.current = true;
+    var unsubscribe = observer.subscribe(_notifyManager.notifyManager.batchCalls(function () {
+      if (mountedRef.current) {
+        forceUpdate(function (x) {
+          return x + 1;
+        });
+      }
+    }));
+    return function () {
+      mountedRef.current = false;
+      unsubscribe();
+    };
+  }, [observer]);
+
+  _react.default.useEffect(function () {
+    // Do not notify on updates because of changes in the options because
+    // these changes should already be reflected in the optimistic result.
+    observer.setQueries(defaultedQueries, {
+      listeners: false
+    });
+  }, [defaultedQueries, observer]);
+
+  return result;
+}

server/node_modules/react-query/lib/react/useQuery.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+exports.useQuery = useQuery;
+
+var _core = require("../core");
+
+var _utils = require("../core/utils");
+
+var _useBaseQuery = require("./useBaseQuery");
+
+function useQuery(arg1, arg2, arg3) {
+  var parsedOptions = (0, _utils.parseQueryArgs)(arg1, arg2, arg3);
+  return (0, _useBaseQuery.useBaseQuery)(parsedOptions, _core.QueryObserver);
+}

server/node_modules/react-query/lib/react/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+
+exports.__esModule = true;
+exports.shouldThrowError = shouldThrowError;
+
+function shouldThrowError(suspense, _useErrorBoundary, params) {
+  // Allow useErrorBoundary function to override throwing behavior on a per-error basis
+  if (typeof _useErrorBoundary === 'function') {
+    return _useErrorBoundary.apply(void 0, params);
+  } // Allow useErrorBoundary to override suspense's throwing behavior
+
+
+  if (typeof _useErrorBoundary === 'boolean') return _useErrorBoundary; // If suspense is enabled default to throwing errors
+
+  return !!suspense;
+}