@ic-reactor/react 3.13.0 → 4.0.0-beta.2

package/dist/index.js

@@ -1,24 +1,472 @@
-// Re-export core (following TanStack Query's pattern)
-// Users can import everything from @ic-reactor/react without needing @ic-reactor/core
-export * from "@ic-reactor/core";
-// Re-export hooks
-export * from "./hooks/index.js";
-// Validation utilities for React
-export * from "./validation.js";
-// React-specific exports
-export * from "./createActorHooks.js";
-export * from "./defineReactor.js";
-export * from "./defineDisplayReactor.js";
-export * from "./createReactorProvider.js";
-export * from "./createQuery.js";
-export * from "./createSuspenseQuery.js";
-export * from "./createInfiniteQuery.js";
-export * from "./createSuspenseInfiniteQuery.js";
-export * from "./createMutation.js";
-export * from "./auth/index.js";
-export * from "./types.js";
-// TanStack Query's marker for a query whose args are not known yet, which the
-// non-suspense query hooks and createQueryFactory take in place of args. It is
-// the same symbol as @tanstack/react-query's, so either import works.
-export { skipToken } from "@tanstack/react-query";
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { createContext, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore, } from "react";
+/** The client of the nearest {@link ReactorProvider}, or none outside one. */
+const ClientContext = createContext(undefined);
+/**
+ * The clients whose disposal this package has run, so that a provider can tell
+ * when React hands it a client it already disposed (see {@link ReactorProvider}).
+ */
+const disposedClients = new WeakSet();
+/*
+ * An internal contract with `@ic-reactor/core`'s `createClient`, not public
+ * API (core's `src/client.ts` documents the other side): `globalThis` holds
+ * how many clients have been made in this realm, each client carries that
+ * count once it was made as its serial, and a getter that says whether it
+ * was disposed. Each client also carries a method that, called with the
+ * client as `this` and a principal's text, returns a frozen view of the
+ * client whose keys, read options, `caller()` and `authState()` are that
+ * principal's (the client itself for one built with `identity`): what
+ * {@link useClient} returns while it renders with a caller that is not the
+ * live one. Each such view carries the client it was made over, which
+ * {@link hold} keeps in its place. `Symbol.for` keys and a count on `globalThis`, so that this
+ * module reads them from whichever copy of core made the client, and imports
+ * nothing of core at run time.
+ */
+const CLIENTS_CREATED = Symbol.for("ic-reactor.clients.created");
+const CLIENT_SERIAL = Symbol.for("ic-reactor.client.serial");
+const CLIENT_DISPOSED = Symbol.for("ic-reactor.client.disposed");
+const CLIENT_AS = Symbol.for("ic-reactor.client.as");
+const CLIENT_OF = Symbol.for("ic-reactor.client.of");
+/** How many clients `createClient` has made in this realm so far. */
+const clientsCreated = () => Number(globalThis[CLIENTS_CREATED]) || 0;
+/*
+ * Disposes an owned client whose render React threw away before committing it.
+ *
+ * React gives a discarded render no cleanup. When a Suspense boundary above
+ * the provider suspends during the provider's first render, or `StrictMode`
+ * calls the `useState` initializer twice in development and keeps one result,
+ * the client built for the render React drops never reaches the effect that
+ * disposes it. By then a child's `useAuth()` may have built its auth (an
+ * `AuthClient`) and subscribed to it, so every abandoned render leaked an auth
+ * and its listeners.
+ *
+ * So an owned client is registered here against its `Held`, the provider's
+ * state, which nothing outside the provider references. If React drops that
+ * state, the registry disposes the client after a garbage collection finds the
+ * state unreachable. That is a backstop, not a lifecycle: no code chooses the
+ * moment, and the language does not even promise it comes, but engines run it
+ * after the next collections, and `dispose()` is idempotent.
+ *
+ * The client is the unregister token, so one `unregister` removes what every
+ * dropped render registered for it. Two moments do: a factory call that hands
+ * the client back as borrowed (see {@link hold}), and the commit of any
+ * provider that renders it. A client that a factory returns again, or that a
+ * tree runs on, is not one React threw away, and only an unmount, or its
+ * owner, may end it.
+ *
+ * Not on a server: a server keeps no state after a component renders, while
+ * the rest of the request still uses the client, so a collection there would
+ * end a client in use. A server's client builds no auth and mounts no
+ * `QueryClient`, so it holds nothing to release anyway.
+ */
+const unclaimed = typeof FinalizationRegistry === "function" &&
+    typeof window !== "undefined" &&
+    !("Deno" in globalThis)
+    ? new FinalizationRegistry((client) => client.dispose())
+    : undefined;
+/**
+ * Calls a provider's factory and decides whether the provider owns what it
+ * returns.
+ *
+ * It owns a client its factory call created, and only that one: the count of
+ * clients is read before the call, and a client whose serial is above it was
+ * made during the call. A client made before (at module scope, one per tab,
+ * and used outside React too) is borrowed. Disposing a borrowed client on
+ * unmount killed it for good: the next provider to mount, the next test's
+ * render or a remounted route got the same client back from its factory,
+ * already disposed, and every call through it was cancelled with no error
+ * anywhere (#780). Its owner, not a provider, decides when it ends.
+ *
+ * A client without a serial, such as a test's spread copy of one, is owned
+ * when some client was made during the call: the one it copies, then.
+ *
+ * An owned client is registered with {@link unclaimed} against this call's
+ * `Held`, until a provider commits it. A borrowed one is never registered,
+ * and a registration that an earlier, dropped render made for it is removed
+ * here: a factory that returns a client again keeps it outside the render. A
+ * lazily shared factory (`() => (client ??= createClient(...))`) is the case:
+ * the render that created the client owns it, and when React throws that
+ * render away the retry gets the same client back as borrowed, then commits
+ * and uses it. Left registered, the client would be disposed under the
+ * mounted tree at the next collection.
+ *
+ * That removal is also how the pattern shows itself, so it is reported in
+ * development (see {@link reportLazilyShared}). Only the call that created a
+ * client registers it, and the first removal ends the registration, so the
+ * report comes once per client.
+ */
+function hold(build) {
+    const before = clientsCreated();
+    const built = build();
+    // A view that a component's useClient() returned keeps its caller for good:
+    // hold the client it was made over, whose caller the tree then follows.
+    const client = built[CLIENT_OF] ?? built;
+    const serial = client[CLIENT_SERIAL];
+    const owned = typeof serial === "number" ? serial > before : clientsCreated() > before;
+    const held = { client, owned };
+    if (owned)
+        unclaimed?.register(held, client, client);
+    else if (unclaimed?.unregister(client))
+        reportLazilyShared();
+    return held;
+}
+/**
+ * Whether to report how a provider's client was handed to it (see
+ * {@link reportDisposed} and {@link reportLazilyShared}).
+ */
+const isDevelopment = () => {
+    try {
+        // Written as is, so that a bundler replaces `process.env.NODE_ENV` with
+        // its value. Without a bundler and without Node, `process` throws, and
+        // the message is shown.
+        return process.env.NODE_ENV !== "production";
+    }
+    catch {
+        return true;
+    }
+};
+/** The disposed clients a provider was handed and that were reported. */
+const reported = new WeakSet();
+/**
+ * Reports, once per client and in development, a borrowed client that its
+ * owner already disposed: a provider cannot replace it (the factory returns
+ * the same one), and nothing else would say why every call is cancelled.
+ */
+function reportDisposed(client) {
+    if (client[CLIENT_DISPOSED] !== true ||
+        reported.has(client) ||
+        !isDevelopment()) {
+        return;
+    }
+    reported.add(client);
+    console.error("[ic-reactor] <ReactorProvider> got a disposed client, so every call is cancelled (client_disposed). " +
+        "A provider disposes only a client its own factory created: create a shared client eagerly and keep it " +
+        "alive, or use client={() => createClient({ ... })}.");
+}
+/**
+ * Reports, in development, a factory that handed back a client which an
+ * earlier factory call created and no provider has committed yet. A lazily
+ * shared factory (`() => (client ??= createClient(...))`) does that, and so
+ * does one that returns a client another provider's factory call created.
+ *
+ * The provider of the call that created such a client owns it, so it disposes
+ * it on unmount under every other tree that uses it; and from the moment React
+ * throws the creating render away until a later render gets the client back, a
+ * garbage collection can dispose it. Both show up late, as calls that are
+ * cancelled, and on React 18 the second window can last a whole fetch of a
+ * suspending child. The pattern shows here first, and `StrictMode`, which
+ * calls the factory twice on every mount, shows it on the first render of a
+ * development build.
+ */
+function reportLazilyShared() {
+    if (!isDevelopment())
+        return;
+    console.warn("[ic-reactor] <ReactorProvider> got a client that an earlier factory call created (client ??= createClient(...)). " +
+        "That call's provider disposes it on unmount, or at a garbage collection if React threw its render away. " +
+        "A provider disposes only a client its own factory created: create a shared client eagerly and keep it " +
+        "alive, or use client={() => createClient({ ... })}.");
+}
+/**
+ * Gives a tree one client: it gets it from `client` once, on the first
+ * render, makes it available to {@link useClient} and {@link useAuth}, renders
+ * TanStack Query's `QueryClientProvider` around the children with the
+ * client's `QueryClient`, and, if its factory created the client, disposes it
+ * when it unmounts.
+ *
+ * Put it at the root of the part of the app that calls canisters, in a
+ * client module (the examples below). On a server it renders inside the
+ * request, so a factory that creates the client runs once per request and no
+ * cache or caller is shared between two users, which a client at module scope
+ * would be.
+ *
+ * Who disposes the client depends on when it was created, not on where the
+ * factory is written. A client the factory call creates belongs to the
+ * provider. A client created before the call, such as one at module scope that
+ * code outside React uses too, is borrowed: the provider never disposes it,
+ * however many times it mounts and unmounts, and the app ends it with
+ * `client.dispose()` if it ever needs to. A factory that creates the shared
+ * client lazily on its first call (`() => (client ??= createClient(...))`)
+ * hands that first provider ownership, and the provider disposes it on
+ * unmount. It can also lose the client before any unmount: when React throws
+ * away the render that created it (see below), the client stays registered
+ * for disposal at collection until the next render gets it back from the
+ * factory, so a garbage collection while the fallback shows disposes the
+ * client the retry then mounts. Create a shared client eagerly instead. In
+ * development, a provider whose factory hands back a client that an earlier
+ * factory call created and no provider has committed yet, as a lazily shared
+ * factory does, logs a warning (under `StrictMode`, on its first render), and
+ * a provider that is given a borrowed client which is already disposed logs an
+ * error.
+ *
+ * Disposal is safe in React's development double-mount (`StrictMode` mounts,
+ * unmounts and mounts every component again at once): the cleanup only
+ * schedules the disposal for the next macrotask, and the second mount cancels
+ * it, so a client in use is never disposed. An unmount that is not followed
+ * by a mount disposes an owned client exactly once.
+ *
+ * React runs no cleanup for a render it throws away before committing it: the
+ * first render of a provider below a Suspense boundary that suspends, or the
+ * `useState` initializer call that `StrictMode` drops in development. An owned
+ * client built for such a render, whose auth a child's {@link useAuth} may
+ * already have built, is disposed once that render's state is garbage
+ * collected, through a `FinalizationRegistry`. That is later than an unmount
+ * would dispose it, at a moment no code chooses, but it is disposed, auth and
+ * listeners with it. A client that the factory returns again, or that a
+ * provider commits, is taken off the registry, whoever owns it. A runtime
+ * without `FinalizationRegistry` never disposes such a client, and a server
+ * never registers one: it builds no auth there, and the rest of the request
+ * still uses it.
+ *
+ * React also runs the effects of a subtree again when it shows a hidden
+ * `Activity` once more, and that can be long after they were cleaned up. If an
+ * owned client was disposed meanwhile, the provider builds another from the
+ * same factory, because a disposed client cannot call, sign in or cache any
+ * more. The cost is that hiding a provider inside an `Activity` drops its
+ * cache: disposing clears the `QueryClient`, and the client built on the next
+ * show starts empty. React cannot tell a hidden subtree from an unmounted one
+ * in the cleanup, so there is no way to keep it. To keep a cache across
+ * hiding, render the provider above the `Activity`, not inside it, or give it
+ * a borrowed client, which is never disposed.
+ *
+ * @example
+ * A client per provider, owned and disposed by it (on a server, one per
+ * request):
+ * ```tsx
+ * "use client"
+ *
+ * import { createClient } from "@ic-reactor/core"
+ * import { ReactorProvider } from "@ic-reactor/react"
+ * import { AuthClient } from "@icp-sdk/auth/client"
+ * import type { ReactNode } from "react"
+ *
+ * export function Providers({ children }: { children: ReactNode }) {
+ *   return (
+ *     <ReactorProvider
+ *       client={() =>
+ *         createClient({ network: "ic", auth: () => new AuthClient() })
+ *       }
+ *     >
+ *       {children}
+ *     </ReactorProvider>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * One client per tab, created at module scope and used outside React too.
+ * The provider borrows it and never disposes it (browser-only: on a server a
+ * module-scope client is shared by every request):
+ * ```tsx
+ * "use client"
+ *
+ * import { createClient } from "@ic-reactor/core"
+ * import { ReactorProvider } from "@ic-reactor/react"
+ * import { AuthClient } from "@icp-sdk/auth/client"
+ * import type { ReactNode } from "react"
+ *
+ * export const client = createClient({
+ *   network: "ic",
+ *   auth: () => new AuthClient(),
+ * })
+ *
+ * export function Providers({ children }: { children: ReactNode }) {
+ *   return <ReactorProvider client={() => client}>{children}</ReactorProvider>
+ * }
+ * ```
+ */
+export function ReactorProvider({ client: build, children, }) {
+    const [held, setHeld] = useState(() => hold(build));
+    const { client, owned } = held;
+    const firstBuild = useRef(build);
+    const replacement = useRef(undefined);
+    const pendingDispose = useRef(undefined);
+    useEffect(() => {
+        // A client a tree runs on is never left to the registry, whoever owns it:
+        // a dropped render may have registered this same client, as the one that
+        // created a lazily shared client does before a retry borrows it.
+        unclaimed?.unregister(client);
+        if (!owned) {
+            // Borrowed: never disposed here, so there is nothing to schedule, to
+            // cancel or to replace.
+            reportDisposed(client);
+            return undefined;
+        }
+        if (disposedClients.has(client)) {
+            // A hidden subtree was shown again after its client was disposed. React
+            // runs this effect twice in development before the state below commits;
+            // both runs must hand it the same client, not build one to drop.
+            if (replacement.current?.of !== client) {
+                replacement.current = { of: client, held: hold(firstBuild.current) };
+            }
+            setHeld(replacement.current.held);
+            return undefined;
+        }
+        // The mount that follows a development unmount: the client is still alive.
+        clearTimeout(pendingDispose.current);
+        pendingDispose.current = undefined;
+        return () => {
+            pendingDispose.current = setTimeout(() => {
+                pendingDispose.current = undefined;
+                disposedClients.add(client);
+                client.dispose();
+            }, 0);
+        };
+    }, [client, owned]);
+    return (_jsx(ClientContext.Provider, { value: client, children: _jsx(QueryClientProvider, { client: client.queryClient, children: children }) }));
+}
+/** The provider's client, or the error that names the provider. */
+function useProvided() {
+    const client = useContext(ClientContext);
+    if (client === undefined) {
+        throw new Error("[ic-reactor] useClient() and useAuth() need a <ReactorProvider> above them: " +
+            "render <ReactorProvider client={() => createClient({ ... })}> around the tree.");
+    }
+    return client;
+}
+/** The principal a server render, and a hydrating render, call as: nobody. */
+const ANONYMOUS = "2vxsx-fae";
+const anonymous = () => ANONYMOUS;
+/**
+ * The client of the nearest {@link ReactorProvider}: the one object that
+ * builds canister handles and query options, and that signs users in and out.
+ *
+ * Call it in the body of each component that builds keys or options, on
+ * every render, and build them from what it returns there, never from a
+ * client held at module scope: they are built for the caller this render
+ * shows. Do not keep what it returns past the render: while a page hydrates
+ * it is a view for the anonymous caller, and a view never moves on. An effect
+ * or a callback that uses it closes over its render's value and lists it in
+ * its dependencies (`react-hooks/exhaustive-deps`), so that it runs again with
+ * the client after hydrating. Kept from the hydrating render anywhere else
+ * (`useState(client)`, `useRef(client)`, a `useMemo` or `useCallback` with
+ * `[]`, a module variable), it stays that view: the component shows the
+ * anonymous caller's data, a read it starts while the user is signed in is
+ * cancelled, and a write through it still signs as the live caller. Nothing
+ * warns about it. A nested {@link ReactorProvider} given it
+ * (`client={() => client}`) holds the client the view was made over.
+ * It follows the client's caller with `useSyncExternalStore`, so a
+ * component that calls it renders again when the caller changes (a sign-in, a
+ * switch of account, a sign-out) and never otherwise: a change of status that
+ * leaves the caller as it is (a session that expired, or one signed in
+ * elsewhere, both call as the anonymous principal) renders nothing. In the
+ * steady state it returns the provider's client object itself.
+ *
+ * On a server, and while a page hydrates, the caller is the anonymous one, as
+ * for {@link useAuth}. In a browser that holds a session, the hydrating render
+ * gets a view of the client for the anonymous caller: its `queryKey`,
+ * `queryOptions`, `caller()` and `authState()` are the anonymous caller's, so
+ * the page finds what the server prefetched and dehydrated and matches its
+ * HTML; everything else (canisters, `mutationOptions`, `signIn`, `signOut`,
+ * the `QueryClient`) is the client's own, and a write signs as the caller
+ * current when it runs. Right after hydrating, React renders the component
+ * again with the client itself, for the user: a read with none of the user's
+ * data yet shows its loading state, and a `useSuspenseQuery` read its
+ * boundary's fallback, until that data arrives. A client built with
+ * `identity` keeps its caller for good and is always returned as it is.
+ *
+ * Three consequences of that move on a signed-in reload:
+ *
+ * - A Suspense boundary that is still dehydrated below a component that
+ *   renders with the caller (this hook or {@link useAuth}), because its lazy
+ *   code is still loading or its streamed HTML has not arrived, is rendered
+ *   on the client when that component moves on: it shows its fallback
+ *   instead of the server's HTML, and React 18 reports a recoverable error.
+ *   Its data is still the user's. A `useAuth()` component also moves on in a
+ *   tab whose session expired or is signed in elsewhere. Render such a boundary where no component
+ *   that renders with the caller sits above it, or pass it in as `children`,
+ *   which a component's own update does not render again.
+ * - A read the hydrating render built may still run once (TanStack Query
+ *   refetches stale data on mount, and an effect may fetch with the view's
+ *   options). It is cancelled before anything is sent. A key that holds data
+ *   keeps it as it was, and a fetch of it resolves with that data. A key with
+ *   none fails (`kind` `"cancelled"`, `code` `"caller_changed"`) until the
+ *   anonymous caller is current again: the hydrating render's own reads never
+ *   show that, but a listener of
+ *   `client.queryClient.getQueryCache().subscribe()` (the client takes no
+ *   `QueryCache` of yours), an effect that awaits the fetch and, for a
+ *   `useSuspenseQuery` read the server rendered without dehydrating its
+ *   data, React's `onRecoverableError` (as the reported error's `cause` on
+ *   React 19) see it, so ignore `kind` `"cancelled"` there.
+ * - Put a Suspense boundary above every component that reads with
+ *   `useSuspenseQuery`, on React 18 and 19 alike. The move is a synchronous
+ *   update, which such a read suspends until the user's data arrives. With a
+ *   boundary above, the boundary shows its fallback, then the user's data,
+ *   and the rest of the page responds meanwhile. With none, React 18 refuses
+ *   the update ("A component suspended while responding to synchronous
+ *   input") and unmounts the root, so a signed-in reload renders nothing.
+ *   React 19 keeps the server's HTML on screen, but until the user's data
+ *   arrives, however long the read and its retries take, a click or any other
+ *   update outside a transition commits nothing, and neither does a
+ *   transition that renders the reading component again.
+ *
+ * @throws Error outside a `ReactorProvider`, naming it.
+ */
+export function useClient() {
+    const client = useProvided();
+    // The view for the server's caller. A client with one caller for good is
+    // its own view and its own server snapshot: it has nothing to move on to
+    // after hydrating.
+    const view = client[CLIENT_AS]?.call(client, ANONYMOUS) ?? client;
+    const principal = useSyncExternalStore(client.subscribe, client.caller, view === client ? client.caller : anonymous);
+    // Only the server snapshot differs from the live caller, and only while a
+    // component hydrates.
+    return principal === client.caller() ? client : view;
+}
+/**
+ * Who a server render, and the first render of a hydrating page, call as:
+ * nobody. It is what `createClient` reports for an anonymous client, one
+ * constant for every render, so that the HTML a server wrote and the markup
+ * the browser's first render produces agree even when the browser holds a
+ * session.
+ */
+const SERVER_STATE = Object.freeze({
+    status: "anonymous",
+    principal: ANONYMOUS,
+});
+const serverState = () => SERVER_STATE;
+/**
+ * Who calls, and how to change it: the client's {@link AuthState} (`status`
+ * and `principal`) with `signIn` and `signOut` forwarded to the client.
+ *
+ * It follows the client with `useSyncExternalStore`, so a component renders
+ * again once per change of status or principal and never otherwise (a renewed
+ * delegation, or a parent that renders, does not). The object it returns is
+ * the same until the state changes, so it is safe in a dependency array or
+ * as a prop of a memoized child.
+ *
+ * On a server, and while a page hydrates, the state is `anonymous`: the
+ * server has no session, and rendering the browser's would not match the
+ * server's HTML. A browser whose state is another one (signed in, or a session
+ * that expired or is signed in elsewhere) renders the component again with its
+ * own state right after hydration; an anonymous one does not, and keeps the
+ * object. A component that reads `status` before then should show the same
+ * thing signed out and while the session is read. Whenever it moves on after
+ * hydrating (a signed-in reload, or a session that expired or is signed in
+ * elsewhere), it renders a Suspense boundary still dehydrated below it on the
+ * client, as for {@link useClient}.
+ *
+ * `signIn` and `signOut` reject like {@link Client.signIn} and
+ * {@link Client.signOut}: on a client built with `identity`, which has no
+ * sign-in, and on a server.
+ *
+ * @throws Error outside a {@link ReactorProvider}.
+ */
+export function useAuth() {
+    const client = useProvided();
+    const state = useSyncExternalStore(client.subscribe, () => {
+        const live = client.authState();
+        // The anonymous state (whose principal is always the anonymous one) is
+        // the server's own object, so an anonymous tab has nothing to move on
+        // to after hydrating.
+        return live.status === "anonymous" ? SERVER_STATE : live;
+    }, serverState);
+    return useMemo(() => ({
+        status: state.status,
+        principal: state.principal,
+        signIn: (options) => client.signIn(options),
+        signOut: (options) => client.signOut(options),
+    }), [client, state]);
+}
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,sFAAsF;AACtF,cAAc,kBAAkB,CAAA;AAEhC,kBAAkB;AAClB,cAAc,kBAAkB,CAAA;AAEhC,iCAAiC;AACjC,cAAc,iBAAiB,CAAA;AAE/B,yBAAyB;AACzB,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,2BAA2B,CAAA;AACzC,cAAc,4BAA4B,CAAA;AAE1C,cAAc,kBAAkB,CAAA;AAChC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AACxC,cAAc,kCAAkC,CAAA;AAChD,cAAc,qBAAqB,CAAA;AAEnC,cAAc,iBAAiB,CAAA;AAE/B,cAAc,YAAY,CAAA;AAE1B,8EAA8E;AAC9E,+EAA+E;AAC/E,sEAAsE;AACtE,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"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"}