@pylo/react 0.7.0 → 0.8.0

package/dist/chunk-ZWYBNMHS.js

@@ -0,0 +1,500 @@
+// src/provider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useSyncExternalStore
+} from "react";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { createPyloClient, resolveEndpoint } from "@pylo/core";
+import { ME_QUERY } from "@pylo/auth";
+
+// src/session/store.ts
+import {
+  graphqlRequest,
+  hasErrors,
+  extractErrorMessage,
+  isUnauthorizedError,
+  shouldRefreshToken,
+  safeRedirectPath,
+  LOGIN_MUTATION,
+  REDEEM_LOGIN_HANDOFF_MUTATION,
+  REFRESH_TOKEN_MUTATION
+} from "@pylo/auth";
+function createSessionStore(options) {
+  var _a;
+  const prefix = (_a = options.keyPrefix) != null ? _a : "pylo";
+  const AUTH_KEY = `${prefix}.auth_token`;
+  const REFRESH_KEY = `${prefix}.refresh_token`;
+  let state = { status: "loading", token: null };
+  let refreshToken = null;
+  let inFlight = null;
+  let ready = null;
+  const listeners = /* @__PURE__ */ new Set();
+  function setState(next) {
+    state = next;
+    for (const listener of listeners) listener();
+  }
+  async function persist(auth, refresh2) {
+    refreshToken = refresh2;
+    await options.storage.setItem(AUTH_KEY, auth);
+    await options.storage.setItem(REFRESH_KEY, refresh2);
+    setState({ status: "signedIn", token: auth });
+  }
+  async function signIn(auth, refresh2) {
+    var _a2;
+    await persist(auth, refresh2);
+    (_a2 = options.onSignIn) == null ? void 0 : _a2.call(options);
+  }
+  async function clear() {
+    var _a2;
+    refreshToken = null;
+    await options.storage.removeItem(AUTH_KEY);
+    await options.storage.removeItem(REFRESH_KEY);
+    setState({ status: "signedOut", token: null });
+    (_a2 = options.onSignOut) == null ? void 0 : _a2.call(options);
+  }
+  async function runRefresh() {
+    await init();
+    if (state.status !== "signedIn") return null;
+    if (!refreshToken) {
+      await clear();
+      return null;
+    }
+    const response = await graphqlRequest(
+      options.endpoint,
+      REFRESH_TOKEN_MUTATION,
+      { input: { refresh_token: refreshToken } }
+    );
+    if (hasErrors(response) || !response.data) {
+      if (isUnauthorizedError(response)) {
+        await clear();
+        return null;
+      }
+      return state.token;
+    }
+    const { auth_token, refresh_token } = response.data.refreshToken.data;
+    await persist(auth_token, refresh_token);
+    return auth_token;
+  }
+  function init() {
+    ready != null ? ready : ready = (async () => {
+      try {
+        const [auth, stored] = await Promise.all([
+          options.storage.getItem(AUTH_KEY),
+          options.storage.getItem(REFRESH_KEY)
+        ]);
+        refreshToken = stored;
+        setState(
+          auth ? { status: "signedIn", token: auth } : { status: "signedOut", token: null }
+        );
+      } catch {
+        refreshToken = null;
+        setState({ status: "signedOut", token: null });
+      }
+    })();
+    return ready;
+  }
+  function refresh() {
+    inFlight != null ? inFlight : inFlight = runRefresh().finally(() => {
+      inFlight = null;
+    });
+    return inFlight;
+  }
+  return {
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    init,
+    async getToken() {
+      await init();
+      if (!state.token) return null;
+      if (shouldRefreshToken(state.token)) return refresh();
+      return state.token;
+    },
+    refresh,
+    async login(email, password) {
+      var _a2;
+      const response = await graphqlRequest(
+        options.endpoint,
+        LOGIN_MUTATION,
+        {
+          input: {
+            email,
+            password,
+            ...options.appId !== void 0 ? { pylo_app_id: options.appId } : {}
+          }
+        }
+      );
+      if (hasErrors(response)) {
+        return {
+          success: false,
+          error: {
+            code: "INVALID_CREDENTIALS",
+            message: (_a2 = extractErrorMessage(response.errors)) != null ? _a2 : "Login failed"
+          }
+        };
+      }
+      if (!response.data) {
+        return {
+          success: false,
+          error: { code: "SERVER_ERROR", message: "No data returned" }
+        };
+      }
+      const { auth_token, refresh_token } = response.data.login.data;
+      await signIn(auth_token, refresh_token);
+      return { success: true, authToken: auth_token, refreshToken: refresh_token };
+    },
+    async redeemHandoff(code, verifier) {
+      var _a2;
+      await init();
+      let response;
+      try {
+        response = await graphqlRequest(
+          options.endpoint,
+          REDEEM_LOGIN_HANDOFF_MUTATION,
+          { input: { code, handoff_verifier: verifier } }
+        );
+      } catch (error) {
+        return {
+          success: false,
+          error: {
+            code: "SIGN_IN_FAILED",
+            message: error instanceof Error ? error.message : "Sign-in failed"
+          }
+        };
+      }
+      if (hasErrors(response) || !response.data) {
+        return {
+          success: false,
+          error: {
+            code: "SIGN_IN_FAILED",
+            message: (_a2 = extractErrorMessage(response.errors)) != null ? _a2 : "Sign-in failed"
+          }
+        };
+      }
+      const { auth_token, refresh_token, redirect } = response.data.redeemLoginHandoff.data;
+      await signIn(auth_token, refresh_token);
+      const safe = safeRedirectPath(redirect);
+      return {
+        success: true,
+        authToken: auth_token,
+        refreshToken: refresh_token,
+        ...safe !== null ? { redirect: safe } : {}
+      };
+    },
+    logout: clear
+  };
+}
+
+// src/session/social.ts
+import {
+  buildSocialStartUrl,
+  createHandoffChallenge,
+  createHandoffVerifier,
+  parseHandoffCallback
+} from "@pylo/auth";
+function failed(code, message) {
+  return { success: false, error: { code, message } };
+}
+function createSocialSignIn(o) {
+  const verifierKey = `${o.keyPrefix}.handoff_verifier`;
+  let completing = null;
+  function redeem(parsed, verifier) {
+    if (!parsed) return failed("SIGN_IN_FAILED", "No sign-in response in this URL");
+    if ("error" in parsed) return failed("SIGN_IN_FAILED", parsed.error);
+    if (!verifier) {
+      return failed("SIGN_IN_FAILED", "No sign-in was started in this browser session");
+    }
+    return o.store.redeemHandoff(parsed.code, verifier);
+  }
+  async function finish(url) {
+    try {
+      const verifier = sessionStorage.getItem(verifierKey);
+      sessionStorage.removeItem(verifierKey);
+      const parsed = parseHandoffCallback(url);
+      if (parsed && url === location.href) {
+        const clean = new URL(url);
+        clean.searchParams.delete("code");
+        clean.searchParams.delete("error");
+        history.replaceState(history.state, "", clean.toString());
+      }
+      return await redeem(parsed, verifier);
+    } catch (error) {
+      return failed("SIGN_IN_FAILED", error instanceof Error ? error.message : "Sign-in failed");
+    }
+  }
+  return {
+    async signInWith(provider, { returnUrl, redirect, invite }) {
+      let verifier;
+      let startUrl;
+      let finalUrl = null;
+      try {
+        verifier = await createHandoffVerifier(o.crypto);
+        const challenge = await createHandoffChallenge(verifier, o.crypto);
+        startUrl = buildSocialStartUrl({
+          endpoint: o.endpoint,
+          provider,
+          appId: o.appId,
+          returnUrl,
+          challenge,
+          ...redirect !== void 0 ? { redirect } : {},
+          ...invite !== void 0 ? { invite } : {}
+        });
+        if (o.openAuthSession) finalUrl = await o.openAuthSession(startUrl, returnUrl);
+      } catch (error) {
+        return failed(
+          "SIGN_IN_FAILED",
+          error instanceof Error ? error.message : "Sign-in failed"
+        );
+      }
+      if (o.openAuthSession) {
+        if (finalUrl === null) return failed("CANCELLED", "Sign-in was cancelled");
+        return redeem(parseHandoffCallback(finalUrl), verifier);
+      }
+      sessionStorage.setItem(verifierKey, verifier);
+      location.assign(startUrl);
+      return new Promise(() => {
+      });
+    },
+    completeSignIn(url) {
+      if (o.openAuthSession) {
+        return Promise.resolve(
+          failed("SIGN_IN_FAILED", "signInWith already completes the sign-in in this environment")
+        );
+      }
+      completing != null ? completing : completing = finish(url != null ? url : location.href).finally(() => {
+        completing = null;
+      });
+      return completing;
+    }
+  };
+}
+
+// src/session/storage.ts
+function createMemoryStorage() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    getItem: async (key) => {
+      var _a;
+      return (_a = store.get(key)) != null ? _a : null;
+    },
+    setItem: async (key, value) => void store.set(key, value),
+    removeItem: async (key) => void store.delete(key)
+  };
+}
+function createLocalStorageAdapter() {
+  let web;
+  try {
+    web = globalThis.localStorage;
+  } catch {
+    web = void 0;
+  }
+  if (!web) return createMemoryStorage();
+  const fallback = createMemoryStorage();
+  return {
+    getItem: async (key) => {
+      try {
+        const value = web.getItem(key);
+        if (value !== null) return value;
+      } catch {
+      }
+      return fallback.getItem(key);
+    },
+    setItem: async (key, value) => {
+      try {
+        web.setItem(key, value);
+      } catch {
+        await fallback.setItem(key, value);
+      }
+    },
+    removeItem: async (key) => {
+      try {
+        web.removeItem(key);
+      } catch {
+      }
+      await fallback.removeItem(key);
+    }
+  };
+}
+
+// src/transport.ts
+import {
+  graphqlRequest as graphqlRequest2,
+  hasErrors as hasErrors2,
+  extractErrorMessage as extractErrorMessage2,
+  isUnauthorizedError as isUnauthorizedError2
+} from "@pylo/auth";
+import { PyloError } from "@pylo/core";
+function createDirectTransport(options) {
+  function send(query, variables, headers, token) {
+    return graphqlRequest2(
+      options.endpoint,
+      query,
+      variables,
+      {
+        ...token !== null ? { token } : {},
+        ...headers !== void 0 ? { headers } : {}
+      }
+    );
+  }
+  return async (query, variables, headers) => {
+    var _a;
+    let response = await send(query, variables, headers, await options.getToken());
+    if (isUnauthorizedError2(response) && options.onUnauthorized) {
+      const token = await options.onUnauthorized();
+      if (token !== null) {
+        response = await send(query, variables, headers, token);
+      }
+    }
+    if (hasErrors2(response)) {
+      throw new PyloError(
+        (_a = extractErrorMessage2(response.errors)) != null ? _a : "GraphQL request failed",
+        response.errors
+      );
+    }
+    if (!response.data) {
+      throw new PyloError("No data returned from GraphQL request");
+    }
+    return response.data;
+  };
+}
+
+// src/provider.tsx
+import { jsx } from "react/jsx-runtime";
+var PyloContext = createContext(null);
+function usePyloContext() {
+  const value = useContext(PyloContext);
+  if (!value) {
+    throw new Error("usePylo* must be used inside <PyloProvider>");
+  }
+  return value;
+}
+var SIGNED_OUT = { status: "signedOut", token: null };
+var NO_OP = () => () => {
+};
+function PyloProvider(props) {
+  var _a, _b;
+  const queryClient = useQueryClient();
+  const endpoint = resolveEndpoint(props.endpoint);
+  const storeRef = useRef(null);
+  const socialRef = useRef(null);
+  const openAuthSessionRef = useRef(props.openAuthSession);
+  openAuthSessionRef.current = props.openAuthSession;
+  if (storeRef.current === null && !props.getToken) {
+    storeRef.current = createSessionStore({
+      endpoint,
+      storage: (_a = props.storage) != null ? _a : createLocalStorageAdapter(),
+      ...props.appId !== void 0 ? { appId: props.appId } : {},
+      ...props.keyPrefix !== void 0 ? { keyPrefix: props.keyPrefix } : {},
+      onSignOut: () => queryClient.clear(),
+      onSignIn: () => void queryClient.invalidateQueries({ queryKey: ["pylo"] })
+    });
+    if (props.appId !== void 0) {
+      socialRef.current = createSocialSignIn({
+        endpoint,
+        appId: props.appId,
+        keyPrefix: (_b = props.keyPrefix) != null ? _b : "pylo",
+        store: storeRef.current,
+        ...props.openAuthSession ? {
+          openAuthSession: (url, returnUrl) => openAuthSessionRef.current(url, returnUrl)
+        } : {},
+        ...props.handoffCrypto ? { crypto: props.handoffCrypto } : {}
+      });
+    }
+  }
+  const store = storeRef.current;
+  const social = socialRef.current;
+  const state = useSyncExternalStore(
+    store ? store.subscribe : NO_OP,
+    store ? store.getState : () => SIGNED_OUT,
+    store ? store.getState : () => SIGNED_OUT
+  );
+  useEffect(() => {
+    void (store == null ? void 0 : store.init());
+  }, [store]);
+  const getTokenProp = props.getToken;
+  const getTokenRef = useRef(getTokenProp);
+  getTokenRef.current = getTokenProp;
+  const isEscapeHatch = getTokenProp !== void 0;
+  const value = useMemo(() => {
+    const getToken = isEscapeHatch ? () => getTokenRef.current() : () => store.getToken();
+    const transport = createDirectTransport({
+      endpoint,
+      getToken,
+      ...store ? { onUnauthorized: () => store.refresh() } : {}
+    });
+    return { transport, endpoint, state, store, social, getToken };
+  }, [endpoint, state, store, social, isEscapeHatch]);
+  return /* @__PURE__ */ jsx(PyloContext.Provider, { value, children: props.children });
+}
+function usePyloTransport() {
+  return usePyloContext().transport;
+}
+function usePyloClient() {
+  const { endpoint, getToken } = usePyloContext();
+  return useMemo(
+    () => createPyloClient({
+      endpoint,
+      auth: async () => {
+        const token = await getToken();
+        return token !== null ? { token } : {};
+      }
+    }),
+    [endpoint, getToken]
+  );
+}
+function usePyloAuth() {
+  const { state, store, social, transport, getToken } = usePyloContext();
+  const isSignedIn = state.status === "signedIn";
+  const me = useQuery({
+    queryKey: ["pylo", "me"],
+    queryFn: async () => {
+      const data = await transport(ME_QUERY, {});
+      return data.me.current_user.data;
+    },
+    enabled: isSignedIn
+  });
+  return {
+    isLoading: state.status === "loading" || isSignedIn && me.isLoading,
+    isSignedIn,
+    user: me.data,
+    login: async (email, password) => {
+      if (!store) {
+        throw new Error("login is unavailable when PyloProvider is given getToken");
+      }
+      return store.login(email, password);
+    },
+    logout: async () => {
+      if (!store) {
+        throw new Error("logout is unavailable when PyloProvider is given getToken");
+      }
+      await store.logout();
+    },
+    signInWith: async (provider, options) => requireSocial("signInWith").signInWith(provider, options),
+    completeSignIn: async (url) => requireSocial("completeSignIn").completeSignIn(url),
+    getToken
+  };
+  function requireSocial(method) {
+    if (!store) {
+      throw new Error(`${method} is unavailable when PyloProvider is given getToken`);
+    }
+    if (!social) throw new Error(`${method} requires PyloProvider's appId`);
+    return social;
+  }
+}
+
+export {
+  createSessionStore,
+  createMemoryStorage,
+  createLocalStorageAdapter,
+  createDirectTransport,
+  PyloProvider,
+  usePyloTransport,
+  usePyloClient,
+  usePyloAuth
+};

package/dist/hooks.js

@@ -1,8 +1,8 @@
 "use client";
 import {
   createPyloHooks
-} from "./chunk-DOPZ5GRU.js";
-import "./chunk-IKQ52QLH.js";
+} from "./chunk-RCW4MW4F.js";
+import "./chunk-ZWYBNMHS.js";
 export {
   createPyloHooks
 };

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { EntityName, EntitySelect, EntityResult } from '@pylo/core';
 export { AggregateFilterInput, AggregateFunction, AggregateGroupByInput, AggregateInput, AggregateInterval, AggregateIntervalUnit, AggregateMetricInput, AggregateOptions, AggregateResult, AggregateRow, AggregateRows, AggregateSortInput, AggregateSortKey, AggregateTotal, ByIdOptions, CallableEntityName, CreateUploadInput, CreateUploadUrlOptions, DimensionInput, DimensionValue, EntityAggregateApi, EntityCapability, EntityFields, EntityMethodName, EntityName, EntityNameWith, EntityRelationPath, EntityRelations, EntityResult, EntitySelect, EventAggregateOptions, EventGroupByInput, EventListFilterInput, EventListOptions, EventMetricInput, FieldName, FilesClient, FilterInput, HasCapability, IngestEvents, ListOptions, ListResult, Me, MetricValue, MutationRequestOptions, NumericFieldName, PaginationData, PaginationInput, PyloError, PyloEvent, PyloEventFieldValue, PyloEventFieldValuesOptions, PyloEventInput, PyloEventListResult, PyloEventProperty, PyloEventPropertyKeysOptions, PyloUploadedFile, QueryInput, QueryInputCondition, QueryOperator, RequestOptions, RowKeyOf, SearchValueInput, SortInput, SortOrder, SystemEntityName, TimeBucketInput, UploadAttachTarget, UploadOptions, UploadProgress, UploadSource, UploadUrl, UpsertInput, VirtualEntityName } from '@pylo/core';
-import { P as PyloStorage } from './provider-DTTtfhib.js';
-export { a as PyloAuth, b as PyloProvider, c as PyloProviderProps, d as createLocalStorageAdapter, e as createMemoryStorage, u as usePyloAuth, f as usePyloClient, g as usePyloTransport } from './provider-DTTtfhib.js';
-import { AuthResult } from '@pylo/auth';
-export { AuthResult, PyloUser } from '@pylo/auth';
+import { AuthResult, SocialProvider } from '@pylo/auth';
+export { AuthResult, HandoffCrypto, PyloUser, SocialProvider } from '@pylo/auth';
+import { P as PyloStorage, a as PyloAuth } from './provider-X8jgqOeN.js';
+export { O as OpenAuthSession, b as PyloProvider, c as PyloProviderProps, S as SocialSignIn, d as SocialSignInResult, e as createLocalStorageAdapter, f as createMemoryStorage, u as usePyloClient, g as usePyloTransport } from './provider-X8jgqOeN.js';
 export { D as DirectTransportOptions, T as Transport, c as createDirectTransport } from './transport-55cSrvQo.js';
 export { InfiniteListOptions, ListHookResult, StartUploadOptions, UploadHookOptions, UploadHookResult, createPyloHooks } from './hooks.js';
 import 'react/jsx-runtime';
@@ -22,7 +22,7 @@ interface SessionStoreOptions {
     /** Namespaces the storage keys, for apps holding more than one session. */
     keyPrefix?: string;
     onSignOut?: () => void;
-    /** Called after a successful login, not after a refresh. */
+    /** Called after a successful login or handoff, not after a refresh. */
     onSignIn?: () => void;
 }
 interface SessionStore {
@@ -34,6 +34,10 @@ interface SessionStore {
     /** Forces a refresh regardless of expiry. Used after a rejected request. */
     refresh(): Promise<string | null>;
     login(email: string, password: string): Promise<AuthResult>;
+    /** Exchanges a social sign-in handoff code. A failure leaves any existing session intact. */
+    redeemHandoff(code: string, verifier: string): Promise<AuthResult & {
+        redirect?: string;
+    }>;
     logout(): Promise<void>;
 }
 declare function createSessionStore(options: SessionStoreOptions): SessionStore;
@@ -83,5 +87,14 @@ type PyloSelect<E extends PyloEntity> = EntitySelect<RegisteredSchema, E>;
  * `typeof <yourSelect>` (see {@link PyloSelect}) for an exact result type.
  */
 type PyloResult<E extends PyloEntity, Sel extends PyloSelect<E>> = EntityResult<RegisteredSchema, E, Sel>;
+/** Providers `signInWith` accepts. Codegen narrows it to those enabled for the app. */
+type RegisteredSocialProvider = PyloRegister extends {
+    socialProvider: infer P extends string;
+} ? P : SocialProvider;
+/** Return URLs `signInWith` accepts. Codegen narrows it to the app's allowlist. */
+type RegisteredSocialReturnUrl = PyloRegister extends {
+    socialReturnUrl: infer U extends string;
+} ? U : string;
+declare const usePyloAuth: () => PyloAuth<RegisteredSocialProvider, RegisteredSocialReturnUrl>;
 
-export { type PyloEntity, type PyloRegister, type PyloResult, type PyloSelect, PyloStorage, type RegisteredSchema, type SessionState, type SessionStatus, type SessionStore, type SessionStoreOptions, createSessionStore };
+export { PyloAuth, type PyloEntity, type PyloRegister, type PyloResult, type PyloSelect, PyloStorage, type RegisteredSchema, type RegisteredSocialProvider, type RegisteredSocialReturnUrl, type SessionState, type SessionStatus, type SessionStore, type SessionStoreOptions, createSessionStore, usePyloAuth };

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   createPyloHooks
-} from "./chunk-DOPZ5GRU.js";
+} from "./chunk-RCW4MW4F.js";
 import {
   PyloProvider,
   createDirectTransport,
@@ -10,10 +10,11 @@ import {
   usePyloAuth,
   usePyloClient,
   usePyloTransport
-} from "./chunk-IKQ52QLH.js";
+} from "./chunk-ZWYBNMHS.js";
 
 // src/index.ts
 import { PyloError } from "@pylo/core";
+var usePyloAuth2 = usePyloAuth;
 export {
   PyloError,
   PyloProvider,
@@ -22,7 +23,7 @@ export {
   createMemoryStorage,
   createPyloHooks,
   createSessionStore,
-  usePyloAuth,
+  usePyloAuth2 as usePyloAuth,
   usePyloClient,
   usePyloTransport
 };

package/dist/provider-X8jgqOeN.d.ts

@@ -0,0 +1,74 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { PyloClient } from '@pylo/core';
+import { SocialProvider, AuthResult, PyloUser, HandoffCrypto } from '@pylo/auth';
+import { T as Transport } from './transport-55cSrvQo.js';
+
+/**
+ * The three operations a session needs from a key-value store. Async because
+ * the native implementations are: Expo's SecureStore has no synchronous API.
+ */
+interface PyloStorage {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+declare function createMemoryStorage(): PyloStorage;
+/**
+ * Persists to `localStorage`, falling back to memory where it is missing or
+ * blocked — server rendering, and Safari's private mode, which throws on write.
+ * Falling back means the session lasts the page's lifetime rather than failing
+ * outright, so a read consults memory whenever the web store comes up empty.
+ */
+declare function createLocalStorageAdapter(): PyloStorage;
+
+type SocialSignInResult = AuthResult & {
+    redirect?: string;
+};
+type OpenAuthSession = (url: string, returnUrl: string) => Promise<string | null>;
+interface SocialSignIn<P extends string = SocialProvider, U extends string = string> {
+    /**
+     * On the web this navigates away and never resolves; finish on the return page
+     * with `completeSignIn`. With `openAuthSession` it resolves once the session ends.
+     */
+    signInWith(provider: P, options: {
+        returnUrl: U;
+        redirect?: string;
+        invite?: string;
+    }): Promise<SocialSignInResult>;
+    /** Finishes a web sign-in from the return page's URL. */
+    completeSignIn(url?: string): Promise<SocialSignInResult>;
+}
+
+interface PyloProviderProps {
+    children: ReactNode;
+    endpoint?: string;
+    appId?: string;
+    storage?: PyloStorage;
+    keyPrefix?: string;
+    /**
+     * Escape hatch for apps whose auth lives elsewhere. Supplying it disables the
+     * session entirely: no login, no logout, no refresh.
+     */
+    getToken?: () => Promise<string | null>;
+    /**
+     * Runs social sign-in in an in-app browser session instead of navigating the
+     * page. Resolves with the URL the session ended on, or `null` when dismissed.
+     */
+    openAuthSession?: OpenAuthSession;
+    handoffCrypto?: HandoffCrypto;
+}
+declare function PyloProvider(props: PyloProviderProps): react_jsx_runtime.JSX.Element;
+declare function usePyloTransport(): Transport;
+declare function usePyloClient<S>(): PyloClient<S>;
+interface PyloAuth<P extends string = SocialProvider, U extends string = string> extends SocialSignIn<P, U> {
+    isLoading: boolean;
+    isSignedIn: boolean;
+    user: PyloUser | undefined;
+    login: (email: string, password: string) => Promise<AuthResult>;
+    logout: () => Promise<void>;
+    getToken: () => Promise<string | null>;
+}
+declare function usePyloAuth(): PyloAuth;
+
+export { type OpenAuthSession as O, type PyloStorage as P, type SocialSignIn as S, type PyloAuth as a, PyloProvider as b, type PyloProviderProps as c, type SocialSignInResult as d, createLocalStorageAdapter as e, createMemoryStorage as f, usePyloTransport as g, usePyloAuth as h, usePyloClient as u };

package/dist/provider.d.ts

@@ -2,5 +2,5 @@ import 'react/jsx-runtime';
 import 'react';
 import '@pylo/core';
 import '@pylo/auth';
-export { a as PyloAuth, b as PyloProvider, c as PyloProviderProps, u as usePyloAuth, f as usePyloClient, g as usePyloTransport } from './provider-DTTtfhib.js';
+export { a as PyloAuth, b as PyloProvider, c as PyloProviderProps, h as usePyloAuth, u as usePyloClient, g as usePyloTransport } from './provider-X8jgqOeN.js';
 import './transport-55cSrvQo.js';

package/dist/provider.js

@@ -3,7 +3,7 @@ import {
   usePyloAuth,
   usePyloClient,
   usePyloTransport
-} from "./chunk-IKQ52QLH.js";
+} from "./chunk-ZWYBNMHS.js";
 export {
   PyloProvider,
   usePyloAuth,