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

package/dist/auth/authentication-manager.d.ts

@@ -1,405 +0,0 @@
-import type { Identity } from "@icp-sdk/core/agent";
-import type { AuthClientLike, AuthClientSignInOptions, AuthState, AuthenticationClientOptions, AuthenticationSignInOptions } from "./types.js";
-import { ClientManager } from "@ic-reactor/core";
-export interface AuthenticationManagerParameters extends AuthenticationClientOptions {
-    clientManager: ClientManager;
-    /**
-     * Bring your own client instance. When provided, IC Reactor never constructs
-     * one and never applies the options below to it.
-     */
-    authClient?: AuthClientLike;
-    /** Canister ID of a locally deployed Internet Identity. */
-    internetIdentityId?: string;
-}
-/**
- * Manages Internet Identity sign-in, session restoration, and authentication
- * state for a {@link ClientManager}.
- *
- * @example
- * ```ts
- * const authentication = new AuthenticationManager({ clientManager })
- * const identity = await authentication.authenticate()
- * ```
- */
-export declare class AuthenticationManager {
-    private authClient?;
-    private authPromise?;
-    private authClientWasProvided;
-    private authStateRevision;
-    private authStateSubscribers;
-    private authClientConstructor?;
-    private authClientConstructorPromise?;
-    private authModuleMissing;
-    private authClientFlavor;
-    private authClientOptions?;
-    private authStateValue;
-    /** See {@link sessionChecked}. */
-    private sessionCheckedValue;
-    private sessionCheckedSubscribers;
-    /** Stops following the current client's session record; see `watchClient()`. */
-    private unwatchClient?;
-    /**
-     * Set when the client's session record changed while an operation of this
-     * manager's own was running; see `followClient()`.
-     */
-    private clientChangedDuringOperation;
-    /** Counts `followClient()` passes, so that only the latest one publishes. */
-    private followRevision;
-    /** Counts `dispose()` calls; see {@link releaseCount}. */
-    private releases;
-    private readonly identityProvider?;
-    /** The provider taken from the `ic_env` cookie, when no caller set one. */
-    private readonly envIdentityProvider?;
-    private readonly internetIdentityId?;
-    /** Whether `internetIdentityId` came from the caller rather than the cookie. */
-    private readonly internetIdentityIdIsExplicit;
-    /**
-     * Which authorize path the locally deployed Internet Identity serves, once
-     * probed. `undefined` means not probed yet; `null` means it serves no sign-in
-     * UI and login should fail with an explanation rather than open a popup onto
-     * a gateway error page.
-     */
-    private localAuthorizePath?;
-    private readonly defaultClientOptions;
-    readonly clientManager: ClientManager;
-    /** The current authentication state. */
-    get authState(): AuthState;
-    constructor({ clientManager, authClient, identityProvider, internetIdentityId, ...clientOptions }: AuthenticationManagerParameters);
-    /** @internal Used by IdentityAttributesManager. */
-    get client(): AuthClientLike | undefined;
-    /**
-     * @internal Used by the auth hooks.
-     *
-     * Whether this manager has checked its client for a session: a restore has
-     * settled, whether it found a session, found none or failed, or a sign-in or
-     * sign-out has completed. Until then {@link authState} is the signed-out state
-     * the manager starts in, which says nothing about the session, so the auth
-     * hooks report `isAuthenticating: true` instead.
-     */
-    get sessionChecked(): boolean;
-    /**
-     * @internal Used by the auth hooks.
-     *
-     * Records that the session has been checked, and tells the auth hooks the
-     * first time. A restore that failed counts: waiting on one that will not be
-     * retried would leave the hooks reporting `isAuthenticating: true` for good.
-     */
-    markSessionChecked(): void;
-    /**
-     * @internal Used by the auth hooks.
-     *
-     * How many times {@link dispose} has run. A restore the hooks started
-     * compares it with the count it began with, to tell whether the manager was
-     * released while it ran.
-     */
-    get releaseCount(): number;
-    /**
-     * @internal Used by the auth hooks.
-     *
-     * Calls `callback` once, when {@link sessionChecked} turns true. Nothing else
-     * announces it when the check that settles it publishes no state, as a
-     * restore that failed before it read the client does not.
-     *
-     * @returns An unsubscribe function.
-     */
-    subscribeSessionChecked(callback: () => void): () => void;
-    /**
-     * Releases the `@icp-sdk/auth` client this manager built.
-     *
-     * A v10 client hooks the page when it is built: activity listeners on
-     * `document`, focus and visibility listeners, a watch on the session record
-     * that every tab shares and, once signed in, a refresh timer. Nothing
-     * releases them when the manager is dropped, so a manager built per mount,
-     * as a server-rendered app builds one in its provider, left one live client
-     * behind on each remount. Call this when you discard the manager, from the
-     * cleanup of whatever built it.
-     *
-     * The client is disposed and forgotten, so a later {@link prepareClient},
-     * {@link login}, {@link logout} or restore that needs a client builds a new
-     * one. That keeps it safe in an effect cleanup under React's StrictMode,
-     * which runs the cleanup and then the effect again on the same manager. With
-     * `@icp-sdk/auth` v8 there is nothing to release, and the manager only drops
-     * its reference. A client passed in as `authClient` belongs to the caller: it
-     * is never disposed, and the manager goes on using it, but stops following its
-     * session record until its next {@link prepareClient}, {@link login} or
-     * {@link authenticate}, so that the caller's client does not keep a
-     * discarded manager alive.
-     *
-     * The auth state and the identity on the agent are left as they are. A
-     * restore reading the client when it is released ends without publishing
-     * what it read, and a sign-in or sign-out under way ends with what the
-     * released client reports. A restore `useAuth()` started stops, and
-     * releases any client it built meanwhile, once no `useAuth()` of this
-     * manager is mounted; one mounted later restores again.
-     *
-     * @example
-     * ```tsx
-     * const [authentication] = useState(
-     *   () => new AuthenticationManager({ clientManager })
-     * )
-     * useEffect(() => () => authentication.dispose(), [authentication])
-     * ```
-     */
-    dispose(): void;
-    /**
-     * Subscribes to auth state changes.
-     *
-     * Callbacks run in the order they subscribed, after the state has changed. A
-     * callback that throws does not stop the others; the first error is rethrown
-     * to whatever made the change once they have all run. When a callback itself
-     * changes the state, the newer state is the last each callback hears.
-     *
-     * @param callback - Function called with the new state.
-     * @returns An unsubscribe function.
-     */
-    subscribeAuthState(callback: (state: AuthState) => void): () => void;
-    /**
-     * Preloads the auth module and creates an AuthClient ahead of time.
-     *
-     * Call (and await) this before wiring up a login button: it makes
-     * {@link login} and {@link IdentityAttributesManager.request} able to open
-     * the identity provider synchronously inside the click handler, which is
-     * what browser popup blockers and the ICRC-29 transport require.
-     */
-    prepareClient(options?: AuthenticationClientOptions): Promise<AuthClientLike | undefined>;
-    /**
-     * Probe the local Internet Identity canister once, and remember what it
-     * serves.
-     *
-     * Only for the derived local provider: an explicitly configured
-     * `identityProvider` is the caller's business, and mainnet is fixed.
-     */
-    private ensureLocalAuthorizePath;
-    /**
-     * Returns an AuthClient without awaiting, or `undefined` when the auth
-     * module has not been loaded yet.
-     *
-     * Callers that must stay inside a user gesture use this instead of
-     * `ensureClient`; awaiting anything before opening the identity
-     * provider window loses the gesture.
-     */
-    getPreparedClient(options?: AuthenticationClientOptions): AuthClientLike | undefined;
-    authenticate: () => Promise<Identity | undefined>;
-    private checkSession;
-    login: (loginOptions?: AuthenticationSignInOptions) => Promise<void>;
-    logout: (options?: {
-        returnTo?: string;
-    }) => Promise<void>;
-    private initializeClient;
-    /**
-     * Makes `client`, which this manager built for `options`, the current one.
-     *
-     * The client it replaces was built here too, for other options: a caller's
-     * `authClient` is never replaced. It was dropped with nothing released, so a
-     * v10 client kept its browser listeners, its state subscription and its
-     * session's refresh timer for the life of the page, one more for each switch
-     * between option sets, such as a one-click sign-in and a plain one (#729).
-     * v10 asks for `dispose()` on a client being discarded, and a new
-     * interaction already takes its signer channel from the old client, so this
-     * adds no failure of its own. A v8 client has nothing to dispose; see
-     * `withSharedIdleCallback()` for the callback it leaves registered.
-     */
-    private installClient;
-    /**
-     * Follows a v10 client's session record, which every tab of the origin
-     * shares.
-     *
-     * The manager learned about the session only through its own calls, while a
-     * v10 client follows the other tabs. After a sign-out in another tab, this
-     * tab's client dropped the session and its manager went on reporting the
-     * user signed in, with the replaced identity on the agent signing calls as
-     * the account the user had left. After a sign-in there as another account,
-     * the manager kept the old account while the client held the new one. When
-     * the old identity's app delegation then lapsed, its mint was refused and
-     * the client removed the record every tab reads, signing the new account out
-     * of every tab (#754). `subscribe()` fires after the record changes, here or
-     * in another tab, and the manager then reads the client again.
-     *
-     * v8 has no notification and never revokes a session, so a v8 client is not
-     * followed.
-     */
-    private watchClient;
-    private stopWatchingClient;
-    /**
-     * Reads the session from `client` after its record changed, and publishes
-     * it when it differs from what this manager holds, as `syncStateFromClient()`
-     * derives it. An error recorded for the session it replaces goes with it.
-     *
-     * An operation of the manager's own, which sets `isAuthenticating`, writes
-     * the record itself and publishes what the client holds when it ends, so a
-     * change during one is read again once it has. So is a change whose read
-     * something else published over.
-     */
-    private followClient;
-    /**
-     * The identity `client` hands out, and whether it vouches for it (see
-     * `vouchesFor()`). Both are read from the same client.
-     */
-    private readClientSession;
-    /**
-     * The session `client` holds, or `undefined` to leave the manager's as it is.
-     *
-     * v10 refuses to hand out an identity while the record names a sign-in it
-     * holds no credential for, as when restoring the account another tab signed
-     * in as failed. The session this manager holds is kept then only while the
-     * record still names its account. One for any other account must not stay
-     * on the agent.
-     */
-    private readFollowedSession;
-    /** @internal Used by IdentityAttributesManager. */
-    signInOrRecoverIdentity(options?: AuthClientSignInOptions): Promise<Identity>;
-    private ensurePreparedClient;
-    /**
-     * Hands the installed client the option shape it actually accepts.
-     *
-     * `authClientOptions` keeps the untranslated values, and `shouldRecreateClient`
-     * compares them with the installed major in mind: two calls that differ only
-     * in a key that major drops count as the same options, so the client is not
-     * rebuilt for them.
-     */
-    private toClientOptions;
-    /**
-     * Options for the agent a v9+ client mints delegations with, off mainnet.
-     *
-     * That client makes its own calls to the Internet Identity canister, through
-     * an agent built from these options alone. Without a root key it checks every
-     * certificate against mainnet's, which a local replica or testnet cannot
-     * satisfy, so sign-in would fail at the first mint. Off mainnet it gets the
-     * replica this app already talks to and fetches that network's root key, the
-     * same trust the app's own agent needs there. When the app passed its own
-     * `agentOptions.rootKey`, which its agent keeps, the minting agent gets that
-     * key instead and verifies against it too. On mainnet nothing is passed, and
-     * the client keeps its defaults.
-     */
-    private sessionAgentOptions;
-    /**
-     * Which canister a v9+ client should pair with `identityProvider`.
-     *
-     * v9+ names a provider by its authorize URL and the canister that mints its
-     * delegations, and nothing about the canister follows from the URL. The
-     * mainnet URL goes with mainnet's canister unless the caller named another.
-     * A canister read from the `ic_env` cookie belongs to a local deployment, so
-     * it never overrides that. Any other URL takes `internetIdentityId`, or the
-     * well-known local canister when the URL is one IC Reactor derived for a
-     * local deployment. A URL the caller set with no canister stays `unknown`.
-     */
-    private identityProviderPairing;
-    /**
-     * Whether `identityProvider` is a local provider IC Reactor chose, from the
-     * `ic_env` cookie or built for the local replica, rather than one a caller
-     * configured.
-     */
-    private isDerivedLocalProvider;
-    /**
-     * Only rebuild the client when the effective options actually changed.
-     *
-     * Recreating on every call would discard the client warmed up by
-     * `prepareClient()` and register a duplicate sign-out callback on the
-     * shared IdleManager singleton each time.
-     */
-    private shouldRecreateClient;
-    /**
-     * Merges constructor-level defaults with per-call overrides and fills in the
-     * network-appropriate identity provider.
-     */
-    private resolveClientOptions;
-    /** Whether the shared agent currently signs as the anonymous principal. */
-    private agentIsAnonymous;
-    /**
-     * @internal Used by IdentityAttributesManager.
-     *
-     * Whether the client vouches for `identity`, given what its
-     * `isAuthenticated()` answered.
-     *
-     * A v8 client's answer is not about the identity it holds. It reads the
-     * delegation expiry v8 keeps in the `localStorage` every tab shares, while
-     * `getIdentity()` returns the identity this client restored or signed in
-     * with, and v8 never reads storage again once it has loaded. When the session
-     * lapses and the user signs in again in another tab, that tab writes a new
-     * expiry, and the answer is yes again for the delegation this tab still
-     * holds, which the replica refuses. So a v8 identity whose own delegation
-     * has expired is not vouched for, whatever the answer. Nor is the anonymous
-     * identity, which a v8 client that loaded signed out, or signed out, goes on
-     * handing out once another tab signs in and the answer turns yes. It signs
-     * no one in.
-     *
-     * A v10 client's answer is about the session it holds, and its identity
-     * replaces its short-lived delegation as it ages, so the delegation it holds
-     * can be past its expiry while the session is live. The answer stands alone.
-     */
-    vouchesFor(identity: Identity | null | undefined, isAuthenticated: boolean): boolean;
-    /**
-     * End a session the client no longer vouches for: put the anonymous
-     * identity on the agent -- which also sweeps the previous user's
-     * caller-scoped cache entries and refetches the rest anonymously -- and
-     * publish the signed-out state.
-     *
-     * A v8 client is also asked to forget the session when its
-     * `isAuthenticated()` answered no, since it keeps handing out the lapsed
-     * delegation until `signOut()` runs. That answer reads the expiry kept in
-     * the `localStorage` every tab shares, so it is no only once the session
-     * stored for every tab is over, and v8's `signOut()` takes no lock and
-     * revokes nothing. `signOut` failing changes nothing here: the delegation is
-     * already unusable, and the agent must not keep it. When the answer was yes,
-     * the delegation this tab holds lapsed under a session another tab has
-     * signed in to since, and `signOut()` would delete that session from the
-     * storage every tab shares. The client is left alone, and `vouchesFor()`
-     * keeps the lapsed delegation it goes on handing out off the agent.
-     *
-     * A v10 client is left alone, as `commitSignedOut()` leaves it. Its
-     * `signOut()` ends the sign-in for every tab of the origin: it takes the
-     * sign-in lock from a sign-in another tab has in progress, which then fails,
-     * revokes whatever session the shared store holds, and removes the record
-     * every tab reads. Another tab may have signed in again since this one last
-     * looked, and finding a session over is not the user asking to sign out.
-     * The client already stopped vouching for the session on its own.
-     *
-     * @param isAuthenticated - What the client's `isAuthenticated()` answered.
-     */
-    private expireSession;
-    private syncStateFromClient;
-    /** @internal Used by IdentityAttributesManager. */
-    ensureClient(options?: AuthenticationClientOptions): Promise<AuthClientLike | undefined>;
-    /** @internal Used by IdentityAttributesManager. */
-    commitIdentity(identity: Identity, isAuthenticated: boolean): Promise<void>;
-    /** @internal Used by IdentityAttributesManager. */
-    setAuthenticating(): void;
-    /** @internal Used by IdentityAttributesManager. */
-    setAuthenticationError(error: Error): void;
-    /** @internal Used by IdentityAttributesManager. */
-    settleAuthenticating(): void;
-    /**
-     * @internal Used by IdentityAttributesManager.
-     *
-     * Signs this manager out after the client lost its session under it, as when
-     * another tab signed out. The client itself is left alone: a v10 sign-out
-     * clears the storage every tab shares and takes the sign-in lock, so it would
-     * also end a sign-in the other tab has made or started since.
-     */
-    commitSignedOut(): void;
-    private getDefaultIdentityProvider;
-    /**
-     * Publishes what a check of the session found, then marks the session
-     * checked. In that order, so the auth hooks never take the state before it
-     * for the answer.
-     */
-    private publishSession;
-    /**
-     * Records a change, then tells every subscriber about it.
-     *
-     * Every subscriber is called even when one throws, and the first error is
-     * rethrown once they all have been, so the caller still sees it. A throw
-     * used to end the loop: an app's subscriber registered at module scope comes
-     * before every `useAuth()`, and one that failed on a sign-in left them all
-     * showing `isAuthenticating: true` while the agent signed as the user.
-     *
-     * A subscriber that changes the state again from its callback has told every
-     * subscriber about that newer state, so the loop stops rather than deliver
-     * this older one after it. The list is copied first, so a subscriber added
-     * during the loop is first called for the next change. `ClientManager`
-     * notifies its subscribers the same way.
-     */
-    private updateState;
-    private loadAuthClientConstructor;
-}
-//# sourceMappingURL=authentication-manager.d.ts.map

package/dist/auth/authentication-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"authentication-manager.d.ts","sourceRoot":"","sources":["../../src/auth/authentication-manager.ts"],"names":[],"mappings":"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"}