@tanstack/solid-query 4.24.10 → 5.0.0-alpha.1

package/build/lib/utils.d.ts

@@ -1,14 +0,0 @@
-import type { SolidQueryKey, SolidQueryFilters, ParseFilterArgs, ParseQueryArgs } from './types';
-import type { QueryFunction, QueryOptions } from '@tanstack/query-core';
-export declare function isQueryKey(value: unknown): value is SolidQueryKey;
-export declare function parseQueryArgs<TOptions extends Omit<QueryOptions<any, any, any, ReturnType<TQueryKey>>, 'queryKey'> & {
-    queryKey?: TQueryKey;
-}, TQueryKey extends () => readonly unknown[] = SolidQueryKey>(arg1: TQueryKey | TOptions, arg2?: QueryFunction<any, ReturnType<TQueryKey>> | TOptions, arg3?: TOptions): ParseQueryArgs<TOptions, TQueryKey>;
-export declare function parseFilterArgs<TFilters extends SolidQueryFilters, TOptions = unknown>(arg1?: SolidQueryKey | TFilters, arg2?: TFilters | TOptions, arg3?: TOptions): [ParseFilterArgs<TFilters>, TOptions | undefined];
-export declare function shouldThrowError<T extends (...args: any[]) => boolean>(_useErrorBoundary: boolean | T | undefined, params: Parameters<T>): boolean;
-export declare function sleep(timeout: number): Promise<void>;
-/**
- * Schedules a microtask.
- * This can be useful to schedule state updates after rendering.
- */
-export declare function scheduleMicrotask(callback: () => void): void;

package/build/lib/utils.esm.js

@@ -1,63 +0,0 @@
-function isQueryKey(value) {
-  return typeof value === 'function';
-} // The parseQuery Args functions helps normalize the arguments into the correct form.
-// Whatever the parameters are, they are normalized into the correct form.
-
-function parseQueryArgs(arg1, arg2, arg3) {
-  if (!isQueryKey(arg1)) {
-    const {
-      queryKey: solidKey,
-      ...opts
-    } = arg1;
-
-    if (solidKey) {
-      return { ...opts,
-        queryKey: solidKey()
-      };
-    }
-
-    return arg1;
-  }
-
-  if (typeof arg2 === 'function') {
-    return { ...arg3,
-      queryKey: arg1(),
-      queryFn: arg2
-    };
-  }
-
-  return { ...arg2,
-    queryKey: arg1()
-  };
-}
-function parseFilterArgs(arg1, arg2, arg3) {
-  return isQueryKey(arg1) ? [{ ...arg2,
-    queryKey: arg1()
-  }, arg3] : [{ ...arg1,
-    queryKey: arg1 == null ? void 0 : arg1.queryKey == null ? void 0 : arg1.queryKey()
-  }, arg2];
-}
-function shouldThrowError(_useErrorBoundary, params) {
-  // Allow useErrorBoundary function to override throwing behavior on a per-error basis
-  if (typeof _useErrorBoundary === 'function') {
-    return _useErrorBoundary(...params);
-  }
-
-  return !!_useErrorBoundary;
-}
-function sleep(timeout) {
-  return new Promise(resolve => {
-    setTimeout(resolve, timeout);
-  });
-}
-/**
- * Schedules a microtask.
- * This can be useful to schedule state updates after rendering.
- */
-
-function scheduleMicrotask(callback) {
-  sleep(0).then(callback);
-}
-
-export { isQueryKey, parseFilterArgs, parseQueryArgs, scheduleMicrotask, shouldThrowError, sleep };
-//# sourceMappingURL=utils.esm.js.map

package/build/lib/utils.esm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.esm.js","sources":["../../src/utils.ts"],"sourcesContent":["import type {\n  SolidQueryKey,\n  SolidQueryFilters,\n  ParseFilterArgs,\n  ParseQueryArgs,\n} from './types'\nimport type { QueryFunction, QueryOptions } from '@tanstack/query-core'\n\nexport function isQueryKey(value: unknown): value is SolidQueryKey {\n  return typeof value === 'function'\n}\n\n// The parseQuery Args functions helps normalize the arguments into the correct form.\n// Whatever the parameters are, they are normalized into the correct form.\nexport function parseQueryArgs<\n  TOptions extends Omit<\n    QueryOptions<any, any, any, ReturnType<TQueryKey>>,\n    'queryKey'\n  > & {\n    queryKey?: TQueryKey\n  },\n  TQueryKey extends () => readonly unknown[] = SolidQueryKey,\n>(\n  arg1: TQueryKey | TOptions,\n  arg2?: QueryFunction<any, ReturnType<TQueryKey>> | TOptions,\n  arg3?: TOptions,\n): ParseQueryArgs<TOptions, TQueryKey> {\n  if (!isQueryKey(arg1)) {\n    const { queryKey: solidKey, ...opts } = arg1 as any\n    if (solidKey) {\n      return {\n        ...opts,\n        queryKey: solidKey(),\n      }\n    }\n    return arg1 as any\n  }\n\n  if (typeof arg2 === 'function') {\n    return { ...arg3, queryKey: arg1(), queryFn: arg2 } as any\n  }\n\n  return { ...arg2, queryKey: arg1() } as any\n}\n\nexport function parseFilterArgs<\n  TFilters extends SolidQueryFilters,\n  TOptions = unknown,\n>(\n  arg1?: SolidQueryKey | TFilters,\n  arg2?: TFilters | TOptions,\n  arg3?: TOptions,\n): [ParseFilterArgs<TFilters>, TOptions | undefined] {\n  return (\n    isQueryKey(arg1)\n      ? [{ ...arg2, queryKey: arg1() }, arg3]\n      : [{ ...arg1, queryKey: arg1?.queryKey?.() }, arg2]\n  ) as [ParseFilterArgs<TFilters>, TOptions]\n}\n\nexport function shouldThrowError<T extends (...args: any[]) => boolean>(\n  _useErrorBoundary: boolean | T | undefined,\n  params: Parameters<T>,\n): boolean {\n  // Allow useErrorBoundary function to override throwing behavior on a per-error basis\n  if (typeof _useErrorBoundary === 'function') {\n    return _useErrorBoundary(...params)\n  }\n\n  return !!_useErrorBoundary\n}\n\nexport function sleep(timeout: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, timeout)\n  })\n}\n\n/**\n * Schedules a microtask.\n * This can be useful to schedule state updates after rendering.\n */\nexport function scheduleMicrotask(callback: () => void) {\n  sleep(0).then(callback)\n}\n"],"names":["isQueryKey","value","parseQueryArgs","arg1","arg2","arg3","queryKey","solidKey","opts","queryFn","parseFilterArgs","shouldThrowError","_useErrorBoundary","params","sleep","timeout","Promise","resolve","setTimeout","scheduleMicrotask","callback","then"],"mappings":"AAQO,SAASA,UAAT,CAAoBC,KAApB,EAA4D;EACjE,OAAO,OAAOA,KAAP,KAAiB,UAAxB,CAAA;AACD;AAGD;;AACO,SAASC,cAAT,CASLC,IATK,EAULC,IAVK,EAWLC,IAXK,EAYgC;AACrC,EAAA,IAAI,CAACL,UAAU,CAACG,IAAD,CAAf,EAAuB;IACrB,MAAM;AAAEG,MAAAA,QAAQ,EAAEC,QAAZ;MAAsB,GAAGC,IAAAA;AAAzB,KAAA,GAAkCL,IAAxC,CAAA;;AACA,IAAA,IAAII,QAAJ,EAAc;MACZ,OAAO,EACL,GAAGC,IADE;AAELF,QAAAA,QAAQ,EAAEC,QAAQ,EAAA;OAFpB,CAAA;AAID,KAAA;;AACD,IAAA,OAAOJ,IAAP,CAAA;AACD,GAAA;;AAED,EAAA,IAAI,OAAOC,IAAP,KAAgB,UAApB,EAAgC;IAC9B,OAAO,EAAE,GAAGC,IAAL;MAAWC,QAAQ,EAAEH,IAAI,EAAzB;AAA6BM,MAAAA,OAAO,EAAEL,IAAAA;KAA7C,CAAA;AACD,GAAA;;EAED,OAAO,EAAE,GAAGA,IAAL;AAAWE,IAAAA,QAAQ,EAAEH,IAAI,EAAA;GAAhC,CAAA;AACD,CAAA;AAEM,SAASO,eAAT,CAILP,IAJK,EAKLC,IALK,EAMLC,IANK,EAO8C;EACnD,OACEL,UAAU,CAACG,IAAD,CAAV,GACI,CAAC,EAAE,GAAGC,IAAL;AAAWE,IAAAA,QAAQ,EAAEH,IAAI,EAAA;AAAzB,GAAD,EAAgCE,IAAhC,CADJ,GAEI,CAAC,EAAE,GAAGF,IAAL;IAAWG,QAAQ,EAAEH,IAAF,IAAEA,IAAAA,GAAAA,KAAAA,CAAAA,GAAAA,IAAI,CAAEG,QAAR,IAAA,IAAA,GAAA,KAAA,CAAA,GAAEH,IAAI,CAAEG,QAAN,EAAA;GAAtB,EAA4CF,IAA5C,CAHN,CAAA;AAKD,CAAA;AAEM,SAASO,gBAAT,CACLC,iBADK,EAELC,MAFK,EAGI;AACT;AACA,EAAA,IAAI,OAAOD,iBAAP,KAA6B,UAAjC,EAA6C;AAC3C,IAAA,OAAOA,iBAAiB,CAAC,GAAGC,MAAJ,CAAxB,CAAA;AACD,GAAA;;EAED,OAAO,CAAC,CAACD,iBAAT,CAAA;AACD,CAAA;AAEM,SAASE,KAAT,CAAeC,OAAf,EAA+C;AACpD,EAAA,OAAO,IAAIC,OAAJ,CAAaC,OAAD,IAAa;AAC9BC,IAAAA,UAAU,CAACD,OAAD,EAAUF,OAAV,CAAV,CAAA;AACD,GAFM,CAAP,CAAA;AAGD,CAAA;AAED;AACA;AACA;AACA;;AACO,SAASI,iBAAT,CAA2BC,QAA3B,EAAiD;AACtDN,EAAAA,KAAK,CAAC,CAAD,CAAL,CAASO,IAAT,CAAcD,QAAd,CAAA,CAAA;AACD;;;;"}

package/build/lib/utils.js

@@ -1,72 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function isQueryKey(value) {
-  return typeof value === 'function';
-} // The parseQuery Args functions helps normalize the arguments into the correct form.
-// Whatever the parameters are, they are normalized into the correct form.
-
-function parseQueryArgs(arg1, arg2, arg3) {
-  if (!isQueryKey(arg1)) {
-    const {
-      queryKey: solidKey,
-      ...opts
-    } = arg1;
-
-    if (solidKey) {
-      return { ...opts,
-        queryKey: solidKey()
-      };
-    }
-
-    return arg1;
-  }
-
-  if (typeof arg2 === 'function') {
-    return { ...arg3,
-      queryKey: arg1(),
-      queryFn: arg2
-    };
-  }
-
-  return { ...arg2,
-    queryKey: arg1()
-  };
-}
-function parseFilterArgs(arg1, arg2, arg3) {
-  return isQueryKey(arg1) ? [{ ...arg2,
-    queryKey: arg1()
-  }, arg3] : [{ ...arg1,
-    queryKey: arg1 == null ? void 0 : arg1.queryKey == null ? void 0 : arg1.queryKey()
-  }, arg2];
-}
-function shouldThrowError(_useErrorBoundary, params) {
-  // Allow useErrorBoundary function to override throwing behavior on a per-error basis
-  if (typeof _useErrorBoundary === 'function') {
-    return _useErrorBoundary(...params);
-  }
-
-  return !!_useErrorBoundary;
-}
-function sleep(timeout) {
-  return new Promise(resolve => {
-    setTimeout(resolve, timeout);
-  });
-}
-/**
- * Schedules a microtask.
- * This can be useful to schedule state updates after rendering.
- */
-
-function scheduleMicrotask(callback) {
-  sleep(0).then(callback);
-}
-
-exports.isQueryKey = isQueryKey;
-exports.parseFilterArgs = parseFilterArgs;
-exports.parseQueryArgs = parseQueryArgs;
-exports.scheduleMicrotask = scheduleMicrotask;
-exports.shouldThrowError = shouldThrowError;
-exports.sleep = sleep;
-//# sourceMappingURL=utils.js.map

package/build/lib/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sources":["../../src/utils.ts"],"sourcesContent":["import type {\n  SolidQueryKey,\n  SolidQueryFilters,\n  ParseFilterArgs,\n  ParseQueryArgs,\n} from './types'\nimport type { QueryFunction, QueryOptions } from '@tanstack/query-core'\n\nexport function isQueryKey(value: unknown): value is SolidQueryKey {\n  return typeof value === 'function'\n}\n\n// The parseQuery Args functions helps normalize the arguments into the correct form.\n// Whatever the parameters are, they are normalized into the correct form.\nexport function parseQueryArgs<\n  TOptions extends Omit<\n    QueryOptions<any, any, any, ReturnType<TQueryKey>>,\n    'queryKey'\n  > & {\n    queryKey?: TQueryKey\n  },\n  TQueryKey extends () => readonly unknown[] = SolidQueryKey,\n>(\n  arg1: TQueryKey | TOptions,\n  arg2?: QueryFunction<any, ReturnType<TQueryKey>> | TOptions,\n  arg3?: TOptions,\n): ParseQueryArgs<TOptions, TQueryKey> {\n  if (!isQueryKey(arg1)) {\n    const { queryKey: solidKey, ...opts } = arg1 as any\n    if (solidKey) {\n      return {\n        ...opts,\n        queryKey: solidKey(),\n      }\n    }\n    return arg1 as any\n  }\n\n  if (typeof arg2 === 'function') {\n    return { ...arg3, queryKey: arg1(), queryFn: arg2 } as any\n  }\n\n  return { ...arg2, queryKey: arg1() } as any\n}\n\nexport function parseFilterArgs<\n  TFilters extends SolidQueryFilters,\n  TOptions = unknown,\n>(\n  arg1?: SolidQueryKey | TFilters,\n  arg2?: TFilters | TOptions,\n  arg3?: TOptions,\n): [ParseFilterArgs<TFilters>, TOptions | undefined] {\n  return (\n    isQueryKey(arg1)\n      ? [{ ...arg2, queryKey: arg1() }, arg3]\n      : [{ ...arg1, queryKey: arg1?.queryKey?.() }, arg2]\n  ) as [ParseFilterArgs<TFilters>, TOptions]\n}\n\nexport function shouldThrowError<T extends (...args: any[]) => boolean>(\n  _useErrorBoundary: boolean | T | undefined,\n  params: Parameters<T>,\n): boolean {\n  // Allow useErrorBoundary function to override throwing behavior on a per-error basis\n  if (typeof _useErrorBoundary === 'function') {\n    return _useErrorBoundary(...params)\n  }\n\n  return !!_useErrorBoundary\n}\n\nexport function sleep(timeout: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, timeout)\n  })\n}\n\n/**\n * Schedules a microtask.\n * This can be useful to schedule state updates after rendering.\n */\nexport function scheduleMicrotask(callback: () => void) {\n  sleep(0).then(callback)\n}\n"],"names":["isQueryKey","value","parseQueryArgs","arg1","arg2","arg3","queryKey","solidKey","opts","queryFn","parseFilterArgs","shouldThrowError","_useErrorBoundary","params","sleep","timeout","Promise","resolve","setTimeout","scheduleMicrotask","callback","then"],"mappings":";;;;AAQO,SAASA,UAAT,CAAoBC,KAApB,EAA4D;EACjE,OAAO,OAAOA,KAAP,KAAiB,UAAxB,CAAA;AACD;AAGD;;AACO,SAASC,cAAT,CASLC,IATK,EAULC,IAVK,EAWLC,IAXK,EAYgC;AACrC,EAAA,IAAI,CAACL,UAAU,CAACG,IAAD,CAAf,EAAuB;IACrB,MAAM;AAAEG,MAAAA,QAAQ,EAAEC,QAAZ;MAAsB,GAAGC,IAAAA;AAAzB,KAAA,GAAkCL,IAAxC,CAAA;;AACA,IAAA,IAAII,QAAJ,EAAc;MACZ,OAAO,EACL,GAAGC,IADE;AAELF,QAAAA,QAAQ,EAAEC,QAAQ,EAAA;OAFpB,CAAA;AAID,KAAA;;AACD,IAAA,OAAOJ,IAAP,CAAA;AACD,GAAA;;AAED,EAAA,IAAI,OAAOC,IAAP,KAAgB,UAApB,EAAgC;IAC9B,OAAO,EAAE,GAAGC,IAAL;MAAWC,QAAQ,EAAEH,IAAI,EAAzB;AAA6BM,MAAAA,OAAO,EAAEL,IAAAA;KAA7C,CAAA;AACD,GAAA;;EAED,OAAO,EAAE,GAAGA,IAAL;AAAWE,IAAAA,QAAQ,EAAEH,IAAI,EAAA;GAAhC,CAAA;AACD,CAAA;AAEM,SAASO,eAAT,CAILP,IAJK,EAKLC,IALK,EAMLC,IANK,EAO8C;EACnD,OACEL,UAAU,CAACG,IAAD,CAAV,GACI,CAAC,EAAE,GAAGC,IAAL;AAAWE,IAAAA,QAAQ,EAAEH,IAAI,EAAA;AAAzB,GAAD,EAAgCE,IAAhC,CADJ,GAEI,CAAC,EAAE,GAAGF,IAAL;IAAWG,QAAQ,EAAEH,IAAF,IAAEA,IAAAA,GAAAA,KAAAA,CAAAA,GAAAA,IAAI,CAAEG,QAAR,IAAA,IAAA,GAAA,KAAA,CAAA,GAAEH,IAAI,CAAEG,QAAN,EAAA;GAAtB,EAA4CF,IAA5C,CAHN,CAAA;AAKD,CAAA;AAEM,SAASO,gBAAT,CACLC,iBADK,EAELC,MAFK,EAGI;AACT;AACA,EAAA,IAAI,OAAOD,iBAAP,KAA6B,UAAjC,EAA6C;AAC3C,IAAA,OAAOA,iBAAiB,CAAC,GAAGC,MAAJ,CAAxB,CAAA;AACD,GAAA;;EAED,OAAO,CAAC,CAACD,iBAAT,CAAA;AACD,CAAA;AAEM,SAASE,KAAT,CAAeC,OAAf,EAA+C;AACpD,EAAA,OAAO,IAAIC,OAAJ,CAAaC,OAAD,IAAa;AAC9BC,IAAAA,UAAU,CAACD,OAAD,EAAUF,OAAV,CAAV,CAAA;AACD,GAFM,CAAP,CAAA;AAGD,CAAA;AAED;AACA;AACA;AACA;;AACO,SAASI,iBAAT,CAA2BC,QAA3B,EAAiD;AACtDN,EAAAA,KAAK,CAAC,CAAD,CAAL,CAASO,IAAT,CAAcD,QAAd,CAAA,CAAA;AACD;;;;;;;;;"}

package/build/lib/utils.mjs

@@ -1,63 +0,0 @@
-function isQueryKey(value) {
-  return typeof value === 'function';
-} // The parseQuery Args functions helps normalize the arguments into the correct form.
-// Whatever the parameters are, they are normalized into the correct form.
-
-function parseQueryArgs(arg1, arg2, arg3) {
-  if (!isQueryKey(arg1)) {
-    const {
-      queryKey: solidKey,
-      ...opts
-    } = arg1;
-
-    if (solidKey) {
-      return { ...opts,
-        queryKey: solidKey()
-      };
-    }
-
-    return arg1;
-  }
-
-  if (typeof arg2 === 'function') {
-    return { ...arg3,
-      queryKey: arg1(),
-      queryFn: arg2
-    };
-  }
-
-  return { ...arg2,
-    queryKey: arg1()
-  };
-}
-function parseFilterArgs(arg1, arg2, arg3) {
-  return isQueryKey(arg1) ? [{ ...arg2,
-    queryKey: arg1()
-  }, arg3] : [{ ...arg1,
-    queryKey: arg1 == null ? void 0 : arg1.queryKey == null ? void 0 : arg1.queryKey()
-  }, arg2];
-}
-function shouldThrowError(_useErrorBoundary, params) {
-  // Allow useErrorBoundary function to override throwing behavior on a per-error basis
-  if (typeof _useErrorBoundary === 'function') {
-    return _useErrorBoundary(...params);
-  }
-
-  return !!_useErrorBoundary;
-}
-function sleep(timeout) {
-  return new Promise(resolve => {
-    setTimeout(resolve, timeout);
-  });
-}
-/**
- * Schedules a microtask.
- * This can be useful to schedule state updates after rendering.
- */
-
-function scheduleMicrotask(callback) {
-  sleep(0).then(callback);
-}
-
-export { isQueryKey, parseFilterArgs, parseQueryArgs, scheduleMicrotask, shouldThrowError, sleep };
-//# sourceMappingURL=utils.mjs.map

package/build/lib/utils.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.mjs","sources":["../../src/utils.ts"],"sourcesContent":["import type {\n  SolidQueryKey,\n  SolidQueryFilters,\n  ParseFilterArgs,\n  ParseQueryArgs,\n} from './types'\nimport type { QueryFunction, QueryOptions } from '@tanstack/query-core'\n\nexport function isQueryKey(value: unknown): value is SolidQueryKey {\n  return typeof value === 'function'\n}\n\n// The parseQuery Args functions helps normalize the arguments into the correct form.\n// Whatever the parameters are, they are normalized into the correct form.\nexport function parseQueryArgs<\n  TOptions extends Omit<\n    QueryOptions<any, any, any, ReturnType<TQueryKey>>,\n    'queryKey'\n  > & {\n    queryKey?: TQueryKey\n  },\n  TQueryKey extends () => readonly unknown[] = SolidQueryKey,\n>(\n  arg1: TQueryKey | TOptions,\n  arg2?: QueryFunction<any, ReturnType<TQueryKey>> | TOptions,\n  arg3?: TOptions,\n): ParseQueryArgs<TOptions, TQueryKey> {\n  if (!isQueryKey(arg1)) {\n    const { queryKey: solidKey, ...opts } = arg1 as any\n    if (solidKey) {\n      return {\n        ...opts,\n        queryKey: solidKey(),\n      }\n    }\n    return arg1 as any\n  }\n\n  if (typeof arg2 === 'function') {\n    return { ...arg3, queryKey: arg1(), queryFn: arg2 } as any\n  }\n\n  return { ...arg2, queryKey: arg1() } as any\n}\n\nexport function parseFilterArgs<\n  TFilters extends SolidQueryFilters,\n  TOptions = unknown,\n>(\n  arg1?: SolidQueryKey | TFilters,\n  arg2?: TFilters | TOptions,\n  arg3?: TOptions,\n): [ParseFilterArgs<TFilters>, TOptions | undefined] {\n  return (\n    isQueryKey(arg1)\n      ? [{ ...arg2, queryKey: arg1() }, arg3]\n      : [{ ...arg1, queryKey: arg1?.queryKey?.() }, arg2]\n  ) as [ParseFilterArgs<TFilters>, TOptions]\n}\n\nexport function shouldThrowError<T extends (...args: any[]) => boolean>(\n  _useErrorBoundary: boolean | T | undefined,\n  params: Parameters<T>,\n): boolean {\n  // Allow useErrorBoundary function to override throwing behavior on a per-error basis\n  if (typeof _useErrorBoundary === 'function') {\n    return _useErrorBoundary(...params)\n  }\n\n  return !!_useErrorBoundary\n}\n\nexport function sleep(timeout: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, timeout)\n  })\n}\n\n/**\n * Schedules a microtask.\n * This can be useful to schedule state updates after rendering.\n */\nexport function scheduleMicrotask(callback: () => void) {\n  sleep(0).then(callback)\n}\n"],"names":["isQueryKey","value","parseQueryArgs","arg1","arg2","arg3","queryKey","solidKey","opts","queryFn","parseFilterArgs","shouldThrowError","_useErrorBoundary","params","sleep","timeout","Promise","resolve","setTimeout","scheduleMicrotask","callback","then"],"mappings":"AAQO,SAASA,UAAT,CAAoBC,KAApB,EAA4D;EACjE,OAAO,OAAOA,KAAP,KAAiB,UAAxB,CAAA;AACD;AAGD;;AACO,SAASC,cAAT,CASLC,IATK,EAULC,IAVK,EAWLC,IAXK,EAYgC;AACrC,EAAA,IAAI,CAACL,UAAU,CAACG,IAAD,CAAf,EAAuB;IACrB,MAAM;AAAEG,MAAAA,QAAQ,EAAEC,QAAZ;MAAsB,GAAGC,IAAAA;AAAzB,KAAA,GAAkCL,IAAxC,CAAA;;AACA,IAAA,IAAII,QAAJ,EAAc;MACZ,OAAO,EACL,GAAGC,IADE;AAELF,QAAAA,QAAQ,EAAEC,QAAQ,EAAA;OAFpB,CAAA;AAID,KAAA;;AACD,IAAA,OAAOJ,IAAP,CAAA;AACD,GAAA;;AAED,EAAA,IAAI,OAAOC,IAAP,KAAgB,UAApB,EAAgC;IAC9B,OAAO,EAAE,GAAGC,IAAL;MAAWC,QAAQ,EAAEH,IAAI,EAAzB;AAA6BM,MAAAA,OAAO,EAAEL,IAAAA;KAA7C,CAAA;AACD,GAAA;;EAED,OAAO,EAAE,GAAGA,IAAL;AAAWE,IAAAA,QAAQ,EAAEH,IAAI,EAAA;GAAhC,CAAA;AACD,CAAA;AAEM,SAASO,eAAT,CAILP,IAJK,EAKLC,IALK,EAMLC,IANK,EAO8C;EACnD,OACEL,UAAU,CAACG,IAAD,CAAV,GACI,CAAC,EAAE,GAAGC,IAAL;AAAWE,IAAAA,QAAQ,EAAEH,IAAI,EAAA;AAAzB,GAAD,EAAgCE,IAAhC,CADJ,GAEI,CAAC,EAAE,GAAGF,IAAL;IAAWG,QAAQ,EAAEH,IAAF,IAAEA,IAAAA,GAAAA,KAAAA,CAAAA,GAAAA,IAAI,CAAEG,QAAR,IAAA,IAAA,GAAA,KAAA,CAAA,GAAEH,IAAI,CAAEG,QAAN,EAAA;GAAtB,EAA4CF,IAA5C,CAHN,CAAA;AAKD,CAAA;AAEM,SAASO,gBAAT,CACLC,iBADK,EAELC,MAFK,EAGI;AACT;AACA,EAAA,IAAI,OAAOD,iBAAP,KAA6B,UAAjC,EAA6C;AAC3C,IAAA,OAAOA,iBAAiB,CAAC,GAAGC,MAAJ,CAAxB,CAAA;AACD,GAAA;;EAED,OAAO,CAAC,CAACD,iBAAT,CAAA;AACD,CAAA;AAEM,SAASE,KAAT,CAAeC,OAAf,EAA+C;AACpD,EAAA,OAAO,IAAIC,OAAJ,CAAaC,OAAD,IAAa;AAC9BC,IAAAA,UAAU,CAACD,OAAD,EAAUF,OAAV,CAAV,CAAA;AACD,GAFM,CAAP,CAAA;AAGD,CAAA;AAED;AACA;AACA;AACA;;AACO,SAASI,iBAAT,CAA2BC,QAA3B,EAAiD;AACtDN,EAAAA,KAAK,CAAC,CAAD,CAAL,CAASO,IAAT,CAAcD,QAAd,CAAA,CAAA;AACD;;;;"}

package/build/solid/QueryClientProvider.jsx

@@ -1,49 +0,0 @@
-import { createContext, useContext, onMount, onCleanup, mergeProps, } from 'solid-js';
-export const defaultContext = createContext(undefined);
-const QueryClientSharingContext = createContext(false);
-// If we are given a context, we will use it.
-// Otherwise, if contextSharing is on, we share the first and at least one
-// instance of the context across the window
-// to ensure that if Solid Query is used across
-// different bundles or microfrontends they will
-// all use the same **instance** of context, regardless
-// of module scoping.
-function getQueryClientContext(context, contextSharing) {
-    if (context) {
-        return context;
-    }
-    if (contextSharing && typeof window !== 'undefined') {
-        if (!window.SolidQueryClientContext) {
-            window.SolidQueryClientContext = defaultContext;
-        }
-        return window.SolidQueryClientContext;
-    }
-    return defaultContext;
-}
-export const useQueryClient = ({ context } = {}) => {
-    const queryClient = useContext(getQueryClientContext(context, useContext(QueryClientSharingContext)));
-    if (!queryClient) {
-        throw new Error('No QueryClient set, use QueryClientProvider to set one');
-    }
-    return queryClient;
-};
-export const QueryClientProvider = (props) => {
-    const mergedProps = mergeProps({
-        contextSharing: false,
-    }, props);
-    onMount(() => {
-        mergedProps.client.mount();
-        if (process.env.NODE_ENV !== 'production' && mergedProps.contextSharing) {
-            mergedProps.client
-                .getLogger()
-                .error(`The contextSharing option has been deprecated and will be removed in the next major version`);
-        }
-    });
-    onCleanup(() => mergedProps.client.unmount());
-    const QueryClientContext = getQueryClientContext(mergedProps.context, mergedProps.contextSharing);
-    return (<QueryClientSharingContext.Provider value={!mergedProps.context && mergedProps.contextSharing}>
-      <QueryClientContext.Provider value={mergedProps.client}>
-        {mergedProps.children}
-      </QueryClientContext.Provider>
-    </QueryClientSharingContext.Provider>);
-};

package/build/solid/__tests__/QueryClientProvider.test.jsx

@@ -1,185 +0,0 @@
-import { render, screen, waitFor } from 'solid-testing-library';
-import { queryKey } from './utils';
-import { QueryCache, QueryClient } from '@tanstack/query-core';
-import { createContext, useContext } from 'solid-js';
-import { renderToString } from 'solid-js/web';
-import { createQuery, QueryClientProvider, useQueryClient } from '..';
-import { createQueryClient, sleep } from './utils';
-describe('QueryClientProvider', () => {
-    it('sets a specific cache for all queries to use', async () => {
-        const key = queryKey();
-        const queryCache = new QueryCache();
-        const queryClient = createQueryClient({ queryCache });
-        function Page() {
-            const query = createQuery(key, async () => {
-                await sleep(10);
-                return 'test';
-            });
-            return (<div>
-          <h1>{query.data}</h1>
-        </div>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await waitFor(() => {
-            return screen.getByText('test');
-        });
-        expect(queryCache.find(key())).toBeDefined();
-    });
-    it('allows multiple caches to be partitioned', async () => {
-        const key1 = queryKey();
-        const key2 = queryKey();
-        const queryCache1 = new QueryCache();
-        const queryCache2 = new QueryCache();
-        const queryClient1 = createQueryClient({ queryCache: queryCache1 });
-        const queryClient2 = createQueryClient({ queryCache: queryCache2 });
-        function Page1() {
-            const query = createQuery(key1, async () => {
-                await sleep(10);
-                return 'test1';
-            });
-            return (<div>
-          <h1>{query.data}</h1>
-        </div>);
-        }
-        function Page2() {
-            const query = createQuery(key2, async () => {
-                await sleep(10);
-                return 'test2';
-            });
-            return (<div>
-          <h1>{query.data}</h1>
-        </div>);
-        }
-        render(() => (<>
-        <QueryClientProvider client={queryClient1}>
-          <Page1 />
-        </QueryClientProvider>
-        <QueryClientProvider client={queryClient2}>
-          <Page2 />
-        </QueryClientProvider>
-      </>));
-        await waitFor(() => screen.getByText('test1'));
-        await waitFor(() => screen.getByText('test2'));
-        expect(queryCache1.find(key1())).toBeDefined();
-        expect(queryCache1.find(key2())).not.toBeDefined();
-        expect(queryCache2.find(key1())).not.toBeDefined();
-        expect(queryCache2.find(key2())).toBeDefined();
-    });
-    it("uses defaultOptions for queries when they don't provide their own config", async () => {
-        const key = queryKey();
-        const queryCache = new QueryCache();
-        const queryClient = createQueryClient({
-            queryCache,
-            defaultOptions: {
-                queries: {
-                    cacheTime: Infinity,
-                },
-            },
-        });
-        function Page() {
-            const query = createQuery(key, async () => {
-                await sleep(10);
-                return 'test';
-            });
-            return (<div>
-          <h1>{query.data}</h1>
-        </div>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await waitFor(() => screen.getByText('test'));
-        expect(queryCache.find(key())).toBeDefined();
-        expect(queryCache.find(key())?.options.cacheTime).toBe(Infinity);
-    });
-    describe('with custom context', () => {
-        it('uses the correct context', async () => {
-            const key = queryKey();
-            const contextOuter = createContext(undefined);
-            const contextInner = createContext(undefined);
-            const queryCacheOuter = new QueryCache();
-            const queryClientOuter = new QueryClient({ queryCache: queryCacheOuter });
-            const queryCacheInner = new QueryCache();
-            const queryClientInner = new QueryClient({ queryCache: queryCacheInner });
-            const queryCacheInnerInner = new QueryCache();
-            const queryClientInnerInner = new QueryClient({
-                queryCache: queryCacheInnerInner,
-            });
-            function Page() {
-                const queryOuter = createQuery(key, async () => 'testOuter', {
-                    context: contextOuter,
-                });
-                const queryInner = createQuery(key, async () => 'testInner', {
-                    context: contextInner,
-                });
-                const queryInnerInner = createQuery(key, async () => 'testInnerInner');
-                return (<div>
-            <h1>
-              {queryOuter.data} {queryInner.data} {queryInnerInner.data}
-            </h1>
-          </div>);
-            }
-            // contextSharing should be ignored when passing a custom context.
-            const contextSharing = true;
-            render(() => (<QueryClientProvider client={queryClientOuter} context={contextOuter}>
-          <QueryClientProvider client={queryClientInner} context={contextInner}>
-            <QueryClientProvider client={queryClientInnerInner} contextSharing={contextSharing}>
-              <Page />
-            </QueryClientProvider>
-          </QueryClientProvider>
-        </QueryClientProvider>));
-            await waitFor(() => screen.getByText('testOuter testInner testInnerInner'));
-        });
-    });
-    describe('useQueryClient', () => {
-        it('should throw an error if no query client has been set', () => {
-            const consoleMock = jest
-                .spyOn(console, 'error')
-                .mockImplementation(() => undefined);
-            function Page() {
-                useQueryClient();
-                return null;
-            }
-            expect(() => render(() => <Page />)).toThrow('No QueryClient set, use QueryClientProvider to set one');
-            consoleMock.mockRestore();
-        });
-        it('should use window to get the context when contextSharing is true', () => {
-            const queryCache = new QueryCache();
-            const queryClient = createQueryClient({ queryCache });
-            let queryClientFromHook;
-            let queryClientFromWindow;
-            function Page() {
-                queryClientFromHook = useQueryClient();
-                queryClientFromWindow = useContext(window.SolidQueryClientContext);
-                return null;
-            }
-            render(() => (<QueryClientProvider client={queryClient} contextSharing={true}>
-          <Page />
-        </QueryClientProvider>));
-            expect(queryClientFromHook).toEqual(queryClient);
-            expect(queryClientFromWindow).toEqual(queryClient);
-        });
-        it.skip('should not use window to get the context when contextSharing is true and window does not exist', () => {
-            const queryCache = new QueryCache();
-            const queryClient = createQueryClient({ queryCache });
-            // Mock a non web browser environment
-            const windowSpy = jest
-                .spyOn(window, 'window', 'get')
-                .mockImplementation(undefined);
-            let queryClientFromHook;
-            function Page() {
-                queryClientFromHook = useQueryClient();
-                return null;
-            }
-            // TODO(lukemurray): fails because renderToString never calls Page
-            // probably an SSR-testing issue we need to fix.
-            renderToString(() => (<QueryClientProvider client={queryClient} contextSharing={true}>
-          <Page />
-        </QueryClientProvider>));
-            expect(queryClientFromHook).toEqual(queryClient);
-            windowSpy.mockRestore();
-        });
-    });
-});

package/build/solid/createBaseQuery.js

@@ -1,81 +0,0 @@
-import { useQueryClient } from './QueryClientProvider';
-import { onMount, onCleanup, createComputed, createResource, on, batch, } from 'solid-js';
-import { createStore, unwrap } from 'solid-js/store';
-import { shouldThrowError } from './utils';
-// Base Query Function that is used to create the query.
-export function createBaseQuery(options, Observer) {
-    const queryClient = useQueryClient({ context: options.context });
-    const emptyData = Symbol('empty');
-    const defaultedOptions = queryClient.defaultQueryOptions(options);
-    defaultedOptions._optimisticResults = 'optimistic';
-    const observer = new Observer(queryClient, defaultedOptions);
-    const [state, setState] = createStore(
-    // @ts-ignore
-    observer.getOptimisticResult(defaultedOptions));
-    const [dataResource, { refetch, mutate }] = createResource(() => {
-        return new Promise((resolve) => {
-            if (!(state.isFetching && state.isLoading)) {
-                if (unwrap(state.data) === emptyData) {
-                    resolve(undefined);
-                }
-                resolve(unwrap(state.data));
-            }
-        });
-    });
-    batch(() => {
-        mutate(() => unwrap(state.data));
-        refetch();
-    });
-    let taskQueue = [];
-    const unsubscribe = observer.subscribe((result) => {
-        taskQueue.push(() => {
-            batch(() => {
-                const unwrappedResult = { ...unwrap(result) };
-                if (unwrappedResult.data === undefined) {
-                    // This is a hack to prevent Solid
-                    // from deleting the data property when it is `undefined`
-                    // ref: https://www.solidjs.com/docs/latest/api#updating-stores
-                    // @ts-ignore
-                    unwrappedResult.data = emptyData;
-                }
-                setState(unwrap(unwrappedResult));
-                mutate(() => unwrap(result.data));
-                refetch();
-            });
-        });
-        queueMicrotask(() => {
-            const taskToRun = taskQueue.pop();
-            if (taskToRun) {
-                taskToRun();
-            }
-            taskQueue = [];
-        });
-    });
-    onCleanup(() => unsubscribe());
-    onMount(() => {
-        observer.setOptions(defaultedOptions, { listeners: false });
-    });
-    createComputed(() => {
-        const newDefaultedOptions = queryClient.defaultQueryOptions(options);
-        observer.setOptions(newDefaultedOptions);
-    });
-    createComputed(on(() => state.status, () => {
-        if (state.isError &&
-            !state.isFetching &&
-            shouldThrowError(observer.options.useErrorBoundary, [
-                state.error,
-                observer.getCurrentQuery(),
-            ])) {
-            throw state.error;
-        }
-    }));
-    const handler = {
-        get(target, prop) {
-            if (prop === 'data') {
-                return dataResource();
-            }
-            return Reflect.get(target, prop);
-        },
-    };
-    return new Proxy(state, handler);
-}

package/build/solid/createInfiniteQuery.js

@@ -1,16 +0,0 @@
-import { InfiniteQueryObserver } from '@tanstack/query-core';
-import { createBaseQuery } from './createBaseQuery';
-import { createComputed } from 'solid-js';
-import { createStore } from 'solid-js/store';
-import { parseQueryArgs } from './utils';
-export function createInfiniteQuery(arg1, arg2, arg3) {
-    // The parseQuery Args functions helps normalize the arguments into the correct form.
-    // Whatever the parameters are, they are normalized into the correct form.
-    const [parsedOptions, setParsedOptions] = createStore(parseQueryArgs(arg1, arg2, arg3));
-    // Watch for changes in the options and update the parsed options.
-    createComputed(() => {
-        const newParsedOptions = parseQueryArgs(arg1, arg2, arg3);
-        setParsedOptions(newParsedOptions);
-    });
-    return createBaseQuery(parsedOptions, InfiniteQueryObserver);
-}

package/build/solid/createQueries.js

@@ -1,39 +0,0 @@
-import { createComputed, onCleanup, onMount } from 'solid-js';
-import { QueriesObserver } from '@tanstack/query-core';
-import { useQueryClient } from './QueryClientProvider';
-import { createStore, unwrap } from 'solid-js/store';
-import { scheduleMicrotask } from './utils';
-export function createQueries(queriesOptions) {
-    const queryClient = useQueryClient({ context: queriesOptions.context });
-    const normalizeOptions = (options) => {
-        const normalizedOptions = { ...options, queryKey: options.queryKey?.() };
-        const defaultedOptions = queryClient.defaultQueryOptions(normalizedOptions);
-        defaultedOptions._optimisticResults = 'optimistic';
-        return defaultedOptions;
-    };
-    const defaultedQueries = queriesOptions.queries.map((options) => normalizeOptions(options));
-    const observer = new QueriesObserver(queryClient, defaultedQueries);
-    const [state, setState] = createStore(observer.getOptimisticResult(defaultedQueries));
-    const taskQueue = [];
-    const unsubscribe = observer.subscribe((result) => {
-        taskQueue.push(() => {
-            setState(unwrap(result));
-        });
-        scheduleMicrotask(() => {
-            const taskToRun = taskQueue.pop();
-            if (taskToRun) {
-                taskToRun();
-                taskQueue.splice(0, taskQueue.length);
-            }
-        });
-    });
-    onCleanup(unsubscribe);
-    onMount(() => {
-        observer.setQueries(defaultedQueries, { listeners: false });
-    });
-    createComputed(() => {
-        const updateDefaultedQueries = queriesOptions.queries.map((options) => normalizeOptions(options));
-        observer.setQueries(updateDefaultedQueries);
-    });
-    return state;
-}

package/build/solid/createQuery.js

@@ -1,16 +0,0 @@
-import { QueryObserver } from '@tanstack/query-core';
-import { createComputed } from 'solid-js';
-import { createStore } from 'solid-js/store';
-import { parseQueryArgs } from './utils';
-import { createBaseQuery } from './createBaseQuery';
-export function createQuery(arg1, arg2, arg3) {
-    // The parseQuery Args functions helps normalize the arguments into the correct form.
-    // Whatever the parameters are, they are normalized into the correct form.
-    const [parsedOptions, setParsedOptions] = createStore(parseQueryArgs(arg1, arg2, arg3));
-    // Watch for changes in the options and update the parsed options.
-    createComputed(() => {
-        const newParsedOptions = parseQueryArgs(arg1, arg2, arg3);
-        setParsedOptions(newParsedOptions);
-    });
-    return createBaseQuery(parsedOptions, QueryObserver);
-}

package/build/solid/useIsFetching.js

@@ -1,23 +0,0 @@
-import { useQueryClient } from './QueryClientProvider';
-import { createSignal, onCleanup, createComputed, createMemo } from 'solid-js';
-import { parseFilterArgs } from './utils';
-export function useIsFetching(arg1, arg2, arg3) {
-    const [filtersObj, optionsObj = {}] = parseFilterArgs(arg1, arg2, arg3);
-    const [filters, setFilters] = createSignal(filtersObj);
-    const [options, setOptions] = createSignal(optionsObj);
-    const queryClient = createMemo(() => useQueryClient({ context: options().context }));
-    const queryCache = createMemo(() => queryClient().getQueryCache());
-    const [fetches, setFetches] = createSignal(queryClient().isFetching(filters));
-    createComputed(() => {
-        const [newFiltersObj, newOptionsObj = {}] = parseFilterArgs(arg1, arg2, arg3);
-        setFilters(newFiltersObj);
-        setOptions(newOptionsObj);
-    });
-    const unsubscribe = queryCache().subscribe(() => {
-        setFetches(queryClient().isFetching(filters()));
-    });
-    onCleanup(() => {
-        unsubscribe();
-    });
-    return fetches;
-}