@tanstack/query-broadcast-client-experimental 4.0.0 → 4.0.5

package/build/stats.json

@@ -0,0 +1,427 @@
+{
+  "version": 2,
+  "tree": {
+    "name": "root",
+    "children": [
+      {
+        "name": "index.production.js",
+        "children": [
+          {
+            "name": "node_modules",
+            "children": [
+              {
+                "name": "broadcast-channel/dist/es",
+                "children": [
+                  {
+                    "uid": "f3f3-117",
+                    "name": "util.js"
+                  },
+                  {
+                    "name": "methods",
+                    "children": [
+                      {
+                        "uid": "f3f3-119",
+                        "name": "native.js"
+                      },
+                      {
+                        "uid": "f3f3-125",
+                        "name": "indexed-db.js"
+                      },
+                      {
+                        "uid": "f3f3-127",
+                        "name": "localstorage.js"
+                      },
+                      {
+                        "uid": "f3f3-129",
+                        "name": "simulate.js"
+                      }
+                    ]
+                  },
+                  {
+                    "uid": "f3f3-123",
+                    "name": "options.js"
+                  },
+                  {
+                    "uid": "f3f3-131",
+                    "name": "method-chooser.js"
+                  },
+                  {
+                    "uid": "f3f3-133",
+                    "name": "broadcast-channel.js"
+                  }
+                ]
+              },
+              {
+                "name": "oblivious-set/dist/es/index.js",
+                "uid": "f3f3-121"
+              }
+            ]
+          },
+          {
+            "name": "packages/query-broadcast-client-experimental/src/index.ts",
+            "uid": "f3f3-135"
+          }
+        ]
+      }
+    ],
+    "isRoot": true
+  },
+  "nodeParts": {
+    "f3f3-117": {
+      "renderedLength": 1601,
+      "gzipLength": 792,
+      "brotliLength": 0,
+      "mainUid": "f3f3-116"
+    },
+    "f3f3-119": {
+      "renderedLength": 1626,
+      "gzipLength": 657,
+      "brotliLength": 0,
+      "mainUid": "f3f3-118"
+    },
+    "f3f3-121": {
+      "renderedLength": 1973,
+      "gzipLength": 727,
+      "brotliLength": 0,
+      "mainUid": "f3f3-120"
+    },
+    "f3f3-123": {
+      "renderedLength": 1205,
+      "gzipLength": 474,
+      "brotliLength": 0,
+      "mainUid": "f3f3-122"
+    },
+    "f3f3-125": {
+      "renderedLength": 8613,
+      "gzipLength": 2551,
+      "brotliLength": 0,
+      "mainUid": "f3f3-124"
+    },
+    "f3f3-127": {
+      "renderedLength": 4823,
+      "gzipLength": 1838,
+      "brotliLength": 0,
+      "mainUid": "f3f3-126"
+    },
+    "f3f3-129": {
+      "renderedLength": 1381,
+      "gzipLength": 477,
+      "brotliLength": 0,
+      "mainUid": "f3f3-128"
+    },
+    "f3f3-131": {
+      "renderedLength": 1738,
+      "gzipLength": 755,
+      "brotliLength": 0,
+      "mainUid": "f3f3-130"
+    },
+    "f3f3-133": {
+      "renderedLength": 6028,
+      "gzipLength": 1726,
+      "brotliLength": 0,
+      "mainUid": "f3f3-132"
+    },
+    "f3f3-135": {
+      "renderedLength": 1707,
+      "gzipLength": 503,
+      "brotliLength": 0,
+      "mainUid": "f3f3-134"
+    }
+  },
+  "nodeMetas": {
+    "f3f3-116": {
+      "id": "/node_modules/broadcast-channel/dist/es/util.js",
+      "moduleParts": {
+        "index.production.js": "f3f3-117"
+      },
+      "imported": [],
+      "importedBy": [
+        {
+          "uid": "f3f3-132"
+        },
+        {
+          "uid": "f3f3-137"
+        },
+        {
+          "uid": "f3f3-130"
+        },
+        {
+          "uid": "f3f3-118"
+        },
+        {
+          "uid": "f3f3-124"
+        },
+        {
+          "uid": "f3f3-126"
+        },
+        {
+          "uid": "f3f3-128"
+        }
+      ]
+    },
+    "f3f3-118": {
+      "id": "/node_modules/broadcast-channel/dist/es/methods/native.js",
+      "moduleParts": {
+        "index.production.js": "f3f3-119"
+      },
+      "imported": [
+        {
+          "uid": "f3f3-116"
+        }
+      ],
+      "importedBy": [
+        {
+          "uid": "f3f3-130"
+        }
+      ]
+    },
+    "f3f3-120": {
+      "id": "/node_modules/oblivious-set/dist/es/index.js",
+      "moduleParts": {
+        "index.production.js": "f3f3-121"
+      },
+      "imported": [],
+      "importedBy": [
+        {
+          "uid": "f3f3-124"
+        },
+        {
+          "uid": "f3f3-126"
+        }
+      ]
+    },
+    "f3f3-122": {
+      "id": "/node_modules/broadcast-channel/dist/es/options.js",
+      "moduleParts": {
+        "index.production.js": "f3f3-123"
+      },
+      "imported": [],
+      "importedBy": [
+        {
+          "uid": "f3f3-132"
+        },
+        {
+          "uid": "f3f3-124"
+        },
+        {
+          "uid": "f3f3-126"
+        }
+      ]
+    },
+    "f3f3-124": {
+      "id": "/node_modules/broadcast-channel/dist/es/methods/indexed-db.js",
+      "moduleParts": {
+        "index.production.js": "f3f3-125"
+      },
+      "imported": [
+        {
+          "uid": "f3f3-116"
+        },
+        {
+          "uid": "f3f3-120"
+        },
+        {
+          "uid": "f3f3-122"
+        }
+      ],
+      "importedBy": [
+        {
+          "uid": "f3f3-130"
+        }
+      ]
+    },
+    "f3f3-126": {
+      "id": "/node_modules/broadcast-channel/dist/es/methods/localstorage.js",
+      "moduleParts": {
+        "index.production.js": "f3f3-127"
+      },
+      "imported": [
+        {
+          "uid": "f3f3-120"
+        },
+        {
+          "uid": "f3f3-122"
+        },
+        {
+          "uid": "f3f3-116"
+        }
+      ],
+      "importedBy": [
+        {
+          "uid": "f3f3-130"
+        }
+      ]
+    },
+    "f3f3-128": {
+      "id": "/node_modules/broadcast-channel/dist/es/methods/simulate.js",
+      "moduleParts": {
+        "index.production.js": "f3f3-129"
+      },
+      "imported": [
+        {
+          "uid": "f3f3-116"
+        }
+      ],
+      "importedBy": [
+        {
+          "uid": "f3f3-130"
+        }
+      ]
+    },
+    "f3f3-130": {
+      "id": "/node_modules/broadcast-channel/dist/es/method-chooser.js",
+      "moduleParts": {
+        "index.production.js": "f3f3-131"
+      },
+      "imported": [
+        {
+          "uid": "f3f3-118"
+        },
+        {
+          "uid": "f3f3-124"
+        },
+        {
+          "uid": "f3f3-126"
+        },
+        {
+          "uid": "f3f3-128"
+        },
+        {
+          "uid": "f3f3-116"
+        }
+      ],
+      "importedBy": [
+        {
+          "uid": "f3f3-132"
+        }
+      ]
+    },
+    "f3f3-132": {
+      "id": "/node_modules/broadcast-channel/dist/es/broadcast-channel.js",
+      "moduleParts": {
+        "index.production.js": "f3f3-133"
+      },
+      "imported": [
+        {
+          "uid": "f3f3-116"
+        },
+        {
+          "uid": "f3f3-130"
+        },
+        {
+          "uid": "f3f3-122"
+        }
+      ],
+      "importedBy": [
+        {
+          "uid": "f3f3-136"
+        }
+      ]
+    },
+    "f3f3-134": {
+      "id": "/packages/query-broadcast-client-experimental/src/index.ts",
+      "moduleParts": {
+        "index.production.js": "f3f3-135"
+      },
+      "imported": [
+        {
+          "uid": "f3f3-136"
+        }
+      ],
+      "importedBy": [],
+      "isEntry": true
+    },
+    "f3f3-136": {
+      "id": "/node_modules/broadcast-channel/dist/es/index.js",
+      "moduleParts": {},
+      "imported": [
+        {
+          "uid": "f3f3-132"
+        },
+        {
+          "uid": "f3f3-137"
+        }
+      ],
+      "importedBy": [
+        {
+          "uid": "f3f3-134"
+        }
+      ]
+    },
+    "f3f3-137": {
+      "id": "/node_modules/broadcast-channel/dist/es/leader-election.js",
+      "moduleParts": {},
+      "imported": [
+        {
+          "uid": "f3f3-116"
+        },
+        {
+          "uid": "f3f3-138"
+        }
+      ],
+      "importedBy": [
+        {
+          "uid": "f3f3-136"
+        }
+      ]
+    },
+    "f3f3-138": {
+      "id": "/node_modules/unload/dist/es/index.js",
+      "moduleParts": {},
+      "imported": [
+        {
+          "uid": "f3f3-139"
+        },
+        {
+          "uid": "f3f3-140"
+        },
+        {
+          "uid": "f3f3-141"
+        }
+      ],
+      "importedBy": [
+        {
+          "uid": "f3f3-137"
+        }
+      ]
+    },
+    "f3f3-139": {
+      "id": "/node_modules/detect-node/index.esm.js",
+      "moduleParts": {},
+      "imported": [],
+      "importedBy": [
+        {
+          "uid": "f3f3-138"
+        }
+      ]
+    },
+    "f3f3-140": {
+      "id": "/node_modules/unload/dist/es/browser.js",
+      "moduleParts": {},
+      "imported": [],
+      "importedBy": [
+        {
+          "uid": "f3f3-138"
+        }
+      ]
+    },
+    "f3f3-141": {
+      "id": "/node_modules/unload/dist/es/node.js",
+      "moduleParts": {},
+      "imported": [],
+      "importedBy": [
+        {
+          "uid": "f3f3-138"
+        }
+      ]
+    }
+  },
+  "env": {
+    "rollup": "2.76.0"
+  },
+  "options": {
+    "gzip": true,
+    "brotli": false,
+    "sourcemap": false
+  }
+}

package/build/types/query-broadcast-client-experimental/src/index.d.ts

@@ -0,0 +1,7 @@
+import type { QueryClient } from '@tanstack/query-core';
+interface BroadcastQueryClientOptions {
+    queryClient: QueryClient;
+    broadcastChannel?: string;
+}
+export declare function broadcastQueryClient({ queryClient, broadcastChannel, }: BroadcastQueryClientOptions): void;
+export {};

package/build/types/query-core/src/focusManager.d.ts

@@ -0,0 +1,16 @@
+import { Subscribable } from './subscribable';
+declare type SetupFn = (setFocused: (focused?: boolean) => void) => (() => void) | undefined;
+export declare class FocusManager extends Subscribable {
+    private focused?;
+    private cleanup?;
+    private setup;
+    constructor();
+    protected onSubscribe(): void;
+    protected onUnsubscribe(): void;
+    setEventListener(setup: SetupFn): void;
+    setFocused(focused?: boolean): void;
+    onFocus(): void;
+    isFocused(): boolean;
+}
+export declare const focusManager: FocusManager;
+export {};

package/build/types/query-core/src/hydration.d.ts

@@ -0,0 +1,34 @@
+import type { QueryClient } from './queryClient';
+import type { Query, QueryState } from './query';
+import type { MutationKey, MutationOptions, QueryKey, QueryOptions } from './types';
+import type { Mutation, MutationState } from './mutation';
+export interface DehydrateOptions {
+    dehydrateMutations?: boolean;
+    dehydrateQueries?: boolean;
+    shouldDehydrateMutation?: ShouldDehydrateMutationFunction;
+    shouldDehydrateQuery?: ShouldDehydrateQueryFunction;
+}
+export interface HydrateOptions {
+    defaultOptions?: {
+        queries?: QueryOptions;
+        mutations?: MutationOptions;
+    };
+}
+interface DehydratedMutation {
+    mutationKey?: MutationKey;
+    state: MutationState;
+}
+interface DehydratedQuery {
+    queryHash: string;
+    queryKey: QueryKey;
+    state: QueryState;
+}
+export interface DehydratedState {
+    mutations: DehydratedMutation[];
+    queries: DehydratedQuery[];
+}
+export declare type ShouldDehydrateQueryFunction = (query: Query) => boolean;
+export declare type ShouldDehydrateMutationFunction = (mutation: Mutation) => boolean;
+export declare function dehydrate(client: QueryClient, options?: DehydrateOptions): DehydratedState;
+export declare function hydrate(client: QueryClient, dehydratedState: unknown, options?: HydrateOptions): void;
+export {};

package/build/types/query-core/src/index.d.ts

@@ -0,0 +1,20 @@
+export { CancelledError } from './retryer';
+export { QueryCache } from './queryCache';
+export { QueryClient } from './queryClient';
+export { QueryObserver } from './queryObserver';
+export { QueriesObserver } from './queriesObserver';
+export { InfiniteQueryObserver } from './infiniteQueryObserver';
+export { MutationCache } from './mutationCache';
+export { MutationObserver } from './mutationObserver';
+export { notifyManager } from './notifyManager';
+export { focusManager } from './focusManager';
+export { onlineManager } from './onlineManager';
+export { hashQueryKey, isError, parseQueryArgs, parseFilterArgs, parseMutationFilterArgs, parseMutationArgs, } from './utils';
+export type { MutationFilters, QueryFilters } from './utils';
+export { isCancelledError } from './retryer';
+export { dehydrate, hydrate } from './hydration';
+export * from './types';
+export type { Query } from './query';
+export type { Mutation } from './mutation';
+export type { Logger } from './logger';
+export type { DehydrateOptions, DehydratedState, HydrateOptions, ShouldDehydrateMutationFunction, ShouldDehydrateQueryFunction, } from './hydration';

package/build/types/query-core/src/infiniteQueryBehavior.d.ts

@@ -0,0 +1,15 @@
+import type { QueryBehavior } from './query';
+import type { InfiniteData, QueryOptions } from './types';
+export declare function infiniteQueryBehavior<TQueryFnData, TError, TData>(): QueryBehavior<TQueryFnData, TError, InfiniteData<TData>>;
+export declare function getNextPageParam(options: QueryOptions<any, any>, pages: unknown[]): unknown | undefined;
+export declare function getPreviousPageParam(options: QueryOptions<any, any>, pages: unknown[]): unknown | undefined;
+/**
+ * Checks if there is a next page.
+ * Returns `undefined` if it cannot be determined.
+ */
+export declare function hasNextPage(options: QueryOptions<any, any, any, any>, pages?: unknown): boolean | undefined;
+/**
+ * Checks if there is a previous page.
+ * Returns `undefined` if it cannot be determined.
+ */
+export declare function hasPreviousPage(options: QueryOptions<any, any, any, any>, pages?: unknown): boolean | undefined;

package/build/types/query-core/src/infiniteQueryObserver.d.ts

@@ -0,0 +1,18 @@
+import type { DefaultedInfiniteQueryObserverOptions, FetchNextPageOptions, FetchPreviousPageOptions, InfiniteData, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, QueryKey } from './types';
+import type { QueryClient } from './queryClient';
+import { NotifyOptions, ObserverFetchOptions, QueryObserver } from './queryObserver';
+import { Query } from './query';
+declare type InfiniteQueryObserverListener<TData, TError> = (result: InfiniteQueryObserverResult<TData, TError>) => void;
+export declare class InfiniteQueryObserver<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserver<TQueryFnData, TError, InfiniteData<TData>, InfiniteData<TQueryData>, TQueryKey> {
+    subscribe: (listener?: InfiniteQueryObserverListener<TData, TError>) => () => void;
+    getCurrentResult: () => InfiniteQueryObserverResult<TData, TError>;
+    protected fetch: (fetchOptions: ObserverFetchOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
+    constructor(client: QueryClient, options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>);
+    protected bindMethods(): void;
+    setOptions(options?: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, notifyOptions?: NotifyOptions): void;
+    getOptimisticResult(options: DefaultedInfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): InfiniteQueryObserverResult<TData, TError>;
+    fetchNextPage({ pageParam, ...options }?: FetchNextPageOptions): Promise<InfiniteQueryObserverResult<TData, TError>>;
+    fetchPreviousPage({ pageParam, ...options }?: FetchPreviousPageOptions): Promise<InfiniteQueryObserverResult<TData, TError>>;
+    protected createResult(query: Query<TQueryFnData, TError, InfiniteData<TQueryData>, TQueryKey>, options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): InfiniteQueryObserverResult<TData, TError>;
+}
+export {};

package/build/types/query-core/src/logger.d.ts

@@ -0,0 +1,8 @@
+export interface Logger {
+    log: LogFunction;
+    warn: LogFunction;
+    error: LogFunction;
+}
+declare type LogFunction = (...args: any[]) => void;
+export declare const defaultLogger: Logger;
+export {};

package/build/types/query-core/src/mutation.d.ts

@@ -0,0 +1,70 @@
+import type { MutationOptions, MutationStatus, MutationMeta } from './types';
+import type { MutationCache } from './mutationCache';
+import type { MutationObserver } from './mutationObserver';
+import { Logger } from './logger';
+import { Removable } from './removable';
+interface MutationConfig<TData, TError, TVariables, TContext> {
+    mutationId: number;
+    mutationCache: MutationCache;
+    options: MutationOptions<TData, TError, TVariables, TContext>;
+    logger?: Logger;
+    defaultOptions?: MutationOptions<TData, TError, TVariables, TContext>;
+    state?: MutationState<TData, TError, TVariables, TContext>;
+    meta?: MutationMeta;
+}
+export interface MutationState<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> {
+    context: TContext | undefined;
+    data: TData | undefined;
+    error: TError | null;
+    failureCount: number;
+    isPaused: boolean;
+    status: MutationStatus;
+    variables: TVariables | undefined;
+}
+interface FailedAction {
+    type: 'failed';
+}
+interface LoadingAction<TVariables, TContext> {
+    type: 'loading';
+    variables?: TVariables;
+    context?: TContext;
+}
+interface SuccessAction<TData> {
+    type: 'success';
+    data: TData;
+}
+interface ErrorAction<TError> {
+    type: 'error';
+    error: TError;
+}
+interface PauseAction {
+    type: 'pause';
+}
+interface ContinueAction {
+    type: 'continue';
+}
+interface SetStateAction<TData, TError, TVariables, TContext> {
+    type: 'setState';
+    state: MutationState<TData, TError, TVariables, TContext>;
+}
+export declare type Action<TData, TError, TVariables, TContext> = ContinueAction | ErrorAction<TError> | FailedAction | LoadingAction<TVariables, TContext> | PauseAction | SetStateAction<TData, TError, TVariables, TContext> | SuccessAction<TData>;
+export declare class Mutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> extends Removable {
+    state: MutationState<TData, TError, TVariables, TContext>;
+    options: MutationOptions<TData, TError, TVariables, TContext>;
+    mutationId: number;
+    meta: MutationMeta | undefined;
+    private observers;
+    private mutationCache;
+    private logger;
+    private retryer?;
+    constructor(config: MutationConfig<TData, TError, TVariables, TContext>);
+    setState(state: MutationState<TData, TError, TVariables, TContext>): void;
+    addObserver(observer: MutationObserver<any, any, any, any>): void;
+    removeObserver(observer: MutationObserver<any, any, any, any>): void;
+    protected optionalRemove(): void;
+    continue(): Promise<TData>;
+    execute(): Promise<TData>;
+    private dispatch;
+}
+export declare function getDefaultState<TData, TError, TVariables, TContext>(): MutationState<TData, TError, TVariables, TContext>;
+export {};

package/build/types/query-core/src/mutationCache.d.ts

@@ -0,0 +1,52 @@
+import { MutationObserver } from './mutationObserver';
+import type { MutationOptions } from './types';
+import type { QueryClient } from './queryClient';
+import { Action, Mutation, MutationState } from './mutation';
+import { MutationFilters } from './utils';
+import { Subscribable } from './subscribable';
+interface MutationCacheConfig {
+    onError?: (error: unknown, variables: unknown, context: unknown, mutation: Mutation<unknown, unknown, unknown>) => void;
+    onSuccess?: (data: unknown, variables: unknown, context: unknown, mutation: Mutation<unknown, unknown, unknown>) => void;
+    onMutate?: (variables: unknown, mutation: Mutation<unknown, unknown, unknown, unknown>) => void;
+}
+interface NotifyEventMutationAdded {
+    type: 'added';
+    mutation: Mutation<any, any, any, any>;
+}
+interface NotifyEventMutationRemoved {
+    type: 'removed';
+    mutation: Mutation<any, any, any, any>;
+}
+interface NotifyEventMutationObserverAdded {
+    type: 'observerAdded';
+    mutation: Mutation<any, any, any, any>;
+    observer: MutationObserver<any, any, any>;
+}
+interface NotifyEventMutationObserverRemoved {
+    type: 'observerRemoved';
+    mutation: Mutation<any, any, any, any>;
+    observer: MutationObserver<any, any, any>;
+}
+interface NotifyEventMutationUpdated {
+    type: 'updated';
+    mutation: Mutation<any, any, any, any>;
+    action: Action<any, any, any, any>;
+}
+declare type MutationCacheNotifyEvent = NotifyEventMutationAdded | NotifyEventMutationRemoved | NotifyEventMutationObserverAdded | NotifyEventMutationObserverRemoved | NotifyEventMutationUpdated;
+declare type MutationCacheListener = (event: MutationCacheNotifyEvent) => void;
+export declare class MutationCache extends Subscribable<MutationCacheListener> {
+    config: MutationCacheConfig;
+    private mutations;
+    private mutationId;
+    constructor(config?: MutationCacheConfig);
+    build<TData, TError, TVariables, TContext>(client: QueryClient, options: MutationOptions<TData, TError, TVariables, TContext>, state?: MutationState<TData, TError, TVariables, TContext>): Mutation<TData, TError, TVariables, TContext>;
+    add(mutation: Mutation<any, any, any, any>): void;
+    remove(mutation: Mutation<any, any, any, any>): void;
+    clear(): void;
+    getAll(): Mutation[];
+    find<TData = unknown, TError = unknown, TVariables = any, TContext = unknown>(filters: MutationFilters): Mutation<TData, TError, TVariables, TContext> | undefined;
+    findAll(filters: MutationFilters): Mutation[];
+    notify(event: MutationCacheNotifyEvent): void;
+    resumePausedMutations(): Promise<void>;
+}
+export {};