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

package/src/auth/types.ts

@@ -1,243 +0,0 @@
-import type { Identity, SignIdentity } from "@icp-sdk/core/agent"
-import type { PartialIdentity } from "@icp-sdk/core/identity"
-import type { Principal } from "@icp-sdk/core/principal"
-
-export interface SignedIdentityAttributes {
-  data: Uint8Array
-  signature: Uint8Array
-}
-
-/**
- * The 32-byte nonce issued by the relying-party canister.
- *
- * A function (or promise) lets the Internet Identity window open while the
- * nonce is still being fetched, so the popup is opened inside the user gesture
- * instead of after it. Every supported `@icp-sdk/auth` requires the function form, and
- * IC Reactor normalizes whichever of these you pass into that thunk.
- */
-export type IdentityAttributeNonce =
-  Uint8Array | Promise<Uint8Array> | (() => Uint8Array | Promise<Uint8Array>)
-
-export interface IdentityAttributeRequest {
-  keys: string[]
-  nonce: IdentityAttributeNonce
-}
-
-export interface IdentityAttributeValues {
-  email?: string
-  name?: string
-  verified_email?: string
-  [key: string]: string | undefined
-}
-
-export interface IdentityAttributeResult {
-  principal: string
-  requestedKeys: string[]
-  signedAttributes: SignedIdentityAttributes
-  decodedAttributes: IdentityAttributeValues
-  completedAt: string
-}
-
-/**
- * The providers that Internet Identity supports for one-click sign-in. Only
- * these three reach the underlying auth client.
- */
-type IdentityAttributeOpenIdProviderAlias = "google" | "apple" | "microsoft"
-
-/**
- * An OpenID provider, either as a well-known alias or as a raw issuer URL.
- *
- * The two forms are **not** interchangeable, and what each one does depends on
- * where it is passed:
- *
- * - An alias (`"google" | "apple" | "microsoft"`) is forwarded to the auth
- *   client, which adds an `openid` search param to the identity provider URL so
- *   the user signs in through that provider directly.
- * - Any other string is treated as a raw issuer URL and is **never** forwarded
- *   to the auth client, so it never affects how the user signs in. It is only
- *   meaningful when passed to {@link IdentityAttributesManager.requestOpenId}
- *   (or `identityAttributeKeys`), which scopes the requested keys to
- *   `openid:<issuer>:<key>`. Passed anywhere else it has no effect at all.
- */
-export type IdentityAttributeOpenIdProvider =
-  IdentityAttributeOpenIdProviderAlias | (string & {})
-
-/** Session key algorithm used for each sign-in. */
-export type AuthClientKeyType = "ECDSA" | "Ed25519"
-
-/** Structural shape of an `@icp-sdk/auth` `AuthClientStorage`. */
-export interface AuthClientStorageLike {
-  get(key: string): Promise<string | CryptoKeyPair | null>
-  set(key: string, value: string | CryptoKeyPair): Promise<void>
-  remove(key: string): Promise<void>
-}
-
-/**
- * Idle-session configuration forwarded to the underlying AuthClient.
- * `@icp-sdk/auth` v8 only; see {@link AuthenticationClientOptions.idleOptions}.
- */
-export interface AuthClientIdleOptions {
-  /** Called once the user has been idle for `idleTimeout` ms. */
-  onIdle?: () => unknown
-  /** Idle timeout in ms. @default 600_000 (10 minutes) */
-  idleTimeout?: number
-  /** Treat scroll events as activity. @default false */
-  captureScroll?: boolean
-  /** Scroll debounce in ms. @default 100 */
-  scrollDebounce?: number
-  /** Disable idle detection entirely. @default false */
-  disableIdle?: boolean
-  /**
-   * Disable the built-in idle callback, which signs the user out and reloads
-   * the page. @default false
-   */
-  disableDefaultIdleCallback?: boolean
-}
-
-export interface AuthenticationClientOptions {
-  /** Identity provider URL. @default "https://id.ai/authorize" */
-  identityProvider?: string | URL
-  /** `window.open` features string for the identity provider popup. */
-  windowOpenerFeatures?: string
-  /**
-   * Provider for one-click sign-in.
-   *
-   * Only the `"google" | "apple" | "microsoft"` aliases reach the auth client.
-   * Any other value is dropped here and has **no effect** — raw issuer URLs are
-   * only meaningful on `requestOpenId`, where they scope the requested keys.
-   * @see {@link IdentityAttributeOpenIdProvider}
-   */
-  openIdProvider?: IdentityAttributeOpenIdProvider
-  /**
-   * Derivation origin for the identity provider.
-   *
-   * Required when the app is served from more than one origin (e.g. a custom
-   * domain plus `<canisterId>.icp0.io`) and every origin must resolve to the
-   * same principal.
-   * @see https://github.com/dfinity/internet-identity/blob/main/docs/internet-identity-spec.adoc
-   */
-  derivationOrigin?: string | URL
-  /**
-   * Persistent storage backend. `@icp-sdk/auth` v8 only: v10 drops it with a
-   * one-time warning. @default IndexedDB
-   */
-  storage?: AuthClientStorageLike
-  /**
-   * Session key algorithm. Use `"Ed25519"` when the storage backend cannot
-   * hold a `CryptoKey`. `@icp-sdk/auth` v8 only: v10 drops it with a one-time
-   * warning. @default "ECDSA"
-   */
-  keyType?: AuthClientKeyType
-  /**
-   * Idle timeout configuration. Pass `{ disableIdle: true }` to opt out of the
-   * default behaviour, which signs the user out and reloads after 10 minutes.
-   *
-   * `@icp-sdk/auth` v8 only. v10 has no equivalent, so IC Reactor drops it
-   * there with a one-time warning: on v10 the identity provider enforces the
-   * idle limit, so pass `maxTimeToIdle` to `login()` and set
-   * `disableBrowserActivity` instead.
-   */
-  idleOptions?: AuthClientIdleOptions
-  /**
-   * An existing identity to authenticate via delegation. `@icp-sdk/auth` v8
-   * only: v10 drops it with a one-time warning.
-   */
-  identity?: SignIdentity | PartialIdentity
-  /**
-   * How the client talks to the identity provider. `"redirect"` requires
-   * `@icp-sdk/auth` v8 or later and is ignored by older versions.
-   * @default "window"
-   */
-  transport?: "window" | "redirect"
-  /**
-   * Stops a v10 client from watching the page for signs of activity, so only
-   * requests keep the session in use.
-   *
-   * `@icp-sdk/auth` v10 only. v8 has no equivalent, so IC Reactor drops it
-   * there with a one-time warning. On v8, `idleOptions` controls idle handling.
-   * @default false
-   */
-  disableBrowserActivity?: boolean
-}
-
-export interface AuthClientSignInOptions {
-  /** The longest the delegation may last, in nanoseconds. */
-  maxTimeToLive?: bigint
-  /**
-   * How long a signed-in user may be idle before the sign-in ends, in
-   * nanoseconds.
-   *
-   * `@icp-sdk/auth` v10 only. v8's sign-in has no idle limit, so IC Reactor
-   * drops it there with a one-time warning. On v8, set `idleOptions` instead.
-   */
-  maxTimeToIdle?: bigint
-  /**
-   * Canisters the delegation is restricted to. `@icp-sdk/auth` v8 only: v10
-   * ignores it, and IC Reactor warns when it is set for a v10 client.
-   */
-  targets?: Principal[]
-}
-
-export interface AuthenticationSignInOptions
-  extends AuthClientSignInOptions, AuthenticationClientOptions {
-  onSuccess?: () => void | Promise<void>
-  onError?: (error?: string) => void | Promise<void>
-}
-
-export interface RequestIdentityAttributesParameters extends AuthenticationClientOptions {
-  keys: string[]
-  nonce: IdentityAttributeNonce
-  /**
-   * Sign in as part of the same identity-provider interaction.
-   * @default true
-   */
-  signIn?: boolean
-  maxTimeToLive?: bigint
-  maxTimeToIdle?: bigint
-  targets?: Principal[]
-}
-
-export interface RequestOpenIdIdentityAttributesParameters extends Omit<
-  RequestIdentityAttributesParameters,
-  "openIdProvider"
-> {
-  /**
-   * Provider the requested `keys` are scoped to, producing
-   * `openid:<issuer>:<key>`.
-   *
-   * Passing one of the `"google" | "apple" | "microsoft"` aliases additionally
-   * routes sign-in through that provider, so the user grants attribute access
-   * in the same step. A raw issuer URL only scopes the keys.
-   * @see {@link IdentityAttributeOpenIdProvider}
-   */
-  openIdProvider: IdentityAttributeOpenIdProvider
-}
-
-/**
- * Structural subset of `@icp-sdk/auth`'s `AuthClient` that IC Reactor relies
- * on. Declared locally so `@icp-sdk/auth` stays an optional peer dependency.
- *
- * Every method here is identical across the supported majors (v8 and v10) --
- * only the option objects handed to the constructor and to `signIn` diverge,
- * and `auth-client-compat.ts` translates those. That is what lets one interface
- * describe both.
- */
-export interface AuthClientLike {
-  getIdentity(): Promise<Identity> | Identity
-  isAuthenticated(): Promise<boolean> | boolean
-  signIn(options?: AuthClientSignInOptions): Promise<Identity>
-  signOut(options?: { returnTo?: string }): Promise<void>
-  requestAttributes(params: {
-    keys: string[]
-    // Every supported `@icp-sdk/auth` takes a thunk, so it can journal the value and replay
-    // the same bytes through a redirect flow.
-    nonce: () => Promise<Uint8Array>
-  }): Promise<SignedIdentityAttributes>
-}
-
-export interface AuthState {
-  identity: Identity | null
-  isAuthenticating: boolean
-  isAuthenticated: boolean
-  error: Error | undefined
-}

package/src/createActorHooks.ts

@@ -1,208 +0,0 @@
-/**
- * Actor Hooks Factory - Creates a full set of React hooks for a reactor instance.
- *
- * This is the primary entry point for using the library in React applications.
- * It generates type-safe hooks for:
- * - Queries (useActorQuery)
- * - Suspense Queries (useActorSuspenseQuery)
- * - Infinite Queries (useActorInfiniteQuery)
- * - Suspense Infinite Queries (useActorSuspenseInfiniteQuery)
- * - Mutations (useActorMutation)
- *
- * @example
- * const { useActorQuery, useActorMutation } = createActorHooks(reactor)
- *
- * // In component
- * const { data } = useActorQuery({ functionName: 'get_user' })
- * const { mutate } = useActorMutation({ functionName: 'update_user' })
- */
-import {
-  Reactor,
-  DisplayReactor,
-  ReactorReturnErr,
-  ReactorReturnOk,
-  ReactorQueryData,
-  BaseActor,
-  FunctionName,
-  ReactorArgs,
-  TransformKey,
-} from "@ic-reactor/core"
-import {
-  UseQueryResult,
-  UseSuspenseQueryResult,
-  UseInfiniteQueryResult,
-  UseSuspenseInfiniteQueryResult,
-  UseMutationResult,
-  InfiniteData,
-} from "@tanstack/react-query"
-import { useActorQuery } from "./hooks/useActorQuery.js"
-import { useActorSuspenseQuery } from "./hooks/useActorSuspenseQuery.js"
-import { useActorInfiniteQuery } from "./hooks/useActorInfiniteQuery.js"
-import { useActorSuspenseInfiniteQuery } from "./hooks/useActorSuspenseInfiniteQuery.js"
-import { useActorMutation } from "./hooks/useActorMutation.js"
-import {
-  useActorMethod,
-  UseActorMethodParameters,
-} from "./hooks/useActorMethod.js"
-import { SkippableInfiniteQueryConfig } from "./createInfiniteQuery.js"
-import { SuspenseInfiniteQueryConfig } from "./createSuspenseInfiniteQuery.js"
-import {
-  SkippableQueryConfig,
-  SuspenseQueryConfig,
-  MutationConfig,
-} from "./types.js"
-
-export type ActorHooks<Service, Transform extends TransformKey> = {
-  // `args` may be `skipToken` here, and not in the suspense hooks below.
-  useActorQuery: {
-    <Method extends FunctionName<Service>>(
-      config: SkippableQueryConfig<
-        Service,
-        Method,
-        Transform,
-        ReactorQueryData<ReactorReturnOk<Service, Method, Transform>>
-      >
-    ): UseQueryResult<
-      ReactorQueryData<ReactorReturnOk<Service, Method, Transform>>,
-      ReactorReturnErr<Service, Method, Transform>
-    >
-    <Method extends FunctionName<Service>, TData>(
-      config: SkippableQueryConfig<Service, Method, Transform, TData>
-    ): UseQueryResult<TData, ReactorReturnErr<Service, Method, Transform>>
-  }
-
-  useActorSuspenseQuery: {
-    <Method extends FunctionName<Service>>(
-      config: SuspenseQueryConfig<
-        Service,
-        Method,
-        Transform,
-        ReactorQueryData<ReactorReturnOk<Service, Method, Transform>>
-      >
-    ): UseSuspenseQueryResult<
-      ReactorQueryData<ReactorReturnOk<Service, Method, Transform>>,
-      ReactorReturnErr<Service, Method, Transform>
-    >
-    <Method extends FunctionName<Service>, TData>(
-      config: SuspenseQueryConfig<Service, Method, Transform, TData>
-    ): UseSuspenseQueryResult<
-      TData,
-      ReactorReturnErr<Service, Method, Transform>
-    >
-  }
-
-  // `Selected` is what `select` returns, so `select` can reshape the pages the
-  // way `createInfiniteQuery` allows. Without `select` it stays `InfiniteData`.
-  useActorInfiniteQuery: <
-    Method extends FunctionName<Service>,
-    TPageParam = unknown,
-    Selected = InfiniteData<
-      ReactorQueryData<ReactorReturnOk<Service, Method, Transform>>,
-      TPageParam
-    >,
-  >(
-    config: SkippableInfiniteQueryConfig<
-      Service,
-      Method,
-      Transform,
-      TPageParam,
-      Selected
-    >
-  ) => UseInfiniteQueryResult<
-    Selected,
-    ReactorReturnErr<Service, Method, Transform>
-  >
-
-  useActorSuspenseInfiniteQuery: <
-    Method extends FunctionName<Service>,
-    TPageParam = unknown,
-    Selected = InfiniteData<
-      ReactorQueryData<ReactorReturnOk<Service, Method, Transform>>,
-      TPageParam
-    >,
-  >(
-    config: SuspenseInfiniteQueryConfig<
-      Service,
-      Method,
-      Transform,
-      TPageParam,
-      Selected
-    >
-  ) => UseSuspenseInfiniteQueryResult<
-    Selected,
-    ReactorReturnErr<Service, Method, Transform>
-  >
-
-  useActorMutation: <
-    Method extends FunctionName<Service>,
-    TOnMutateResult = unknown,
-  >(
-    config: MutationConfig<Service, Method, Transform, TOnMutateResult>
-  ) => UseMutationResult<
-    ReactorReturnOk<Service, Method, Transform>,
-    ReactorReturnErr<Service, Method, Transform>,
-    // Without this TVariables defaults to `unknown` and mutate/mutateAsync
-    // accept anything; the standalone hook and createMutation both pass it.
-    ReactorArgs<Service, Method, Transform>,
-    TOnMutateResult
-  >
-
-  useActorMethod: <Method extends FunctionName<Service>>(
-    config: Omit<
-      UseActorMethodParameters<Service, Method, Transform>,
-      "reactor"
-    >
-  ) => ReturnType<typeof useActorMethod<Service, Method, Transform>>
-}
-
-export function createActorHooks<Service>(
-  reactor: DisplayReactor<Service>
-): ActorHooks<Service, "display">
-
-export function createActorHooks<
-  Service = BaseActor,
-  Transform extends TransformKey = "candid",
->(reactor: Reactor<Service, Transform>): ActorHooks<Service, Transform>
-
-export function createActorHooks<Service, Transform extends TransformKey>(
-  reactor: Reactor<Service, Transform>
-): ActorHooks<Service, Transform> {
-  return {
-    useActorQuery: ((config: any) =>
-      useActorQuery({ ...config, reactor })) as ActorHooks<
-      Service,
-      Transform
-    >["useActorQuery"],
-
-    useActorSuspenseQuery: ((config: any) =>
-      useActorSuspenseQuery({ ...config, reactor })) as ActorHooks<
-      Service,
-      Transform
-    >["useActorSuspenseQuery"],
-
-    useActorInfiniteQuery: ((config: any) =>
-      useActorInfiniteQuery({ ...config, reactor })) as ActorHooks<
-      Service,
-      Transform
-    >["useActorInfiniteQuery"],
-
-    useActorSuspenseInfiniteQuery: ((config: any) =>
-      useActorSuspenseInfiniteQuery({ ...config, reactor })) as ActorHooks<
-      Service,
-      Transform
-    >["useActorSuspenseInfiniteQuery"],
-
-    useActorMutation: ((config: any) =>
-      useActorMutation({ ...config, reactor })) as ActorHooks<
-      Service,
-      Transform
-    >["useActorMutation"],
-
-    useActorMethod: (config) =>
-      useActorMethod({ ...config, reactor } as UseActorMethodParameters<
-        Service,
-        any,
-        Transform
-      >),
-  }
-}