@pylo/react 0.7.0 → 0.9.0

package/README.md

@@ -1,113 +1,11 @@
 # @pylo/react
 
-Type-safe Pylo SDK for React single-page apps. Hooks, a session provider, and a
-typed client, generated from your own Pylo schema.
+Type-safe Pylo SDK for React single-page apps, such as Vite.
 
-For Next.js use [`@pylo/nextjs`](../nextjs), which keeps tokens in httpOnly
-cookies. For Expo and React Native use [`@pylo/expo`](../expo).
+## Documentation
 
-## Install
+[https://docs.pyloapp.com/getting-started/quickstart-react](https://docs.pyloapp.com/getting-started/quickstart-react)
 
-```bash
-npm install @pylo/react @tanstack/react-query
-```
+## License
 
-## Generate types
-
-Add a `pylo.config.ts` at your project root, then run the generator. It writes
-`.pylo/index.ts` and registers the schema, so no `declare module` is needed.
-
-```bash
-npx pylo generate
-```
-
-## Set up
-
-Your app owns the QueryClient. `PyloProvider` goes inside it, because signing
-out clears the query cache.
-
-```tsx
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { PyloProvider } from "@pylo/react";
-
-const queryClient = new QueryClient();
-
-export function App() {
-  return (
-    <QueryClientProvider client={queryClient}>
-      <PyloProvider appId={import.meta.env.VITE_PYLO_APP_ID}>
-        <Routes />
-      </PyloProvider>
-    </QueryClientProvider>
-  );
-}
-```
-
-## Sign in
-
-```tsx
-import { usePyloAuth } from "@pylo/react";
-
-function SignIn() {
-  const { isLoading, isSignedIn, user, login, logout } = usePyloAuth();
-
-  if (isLoading) return <Spinner />;
-  if (isSignedIn) return <button onClick={() => logout()}>Sign out {user?.email}</button>;
-
-  return <button onClick={() => login(email, password)}>Sign in</button>;
-}
-```
-
-`isLoading` stays true until stored tokens have been read, so an already
-signed-in user never sees a login screen flash.
-
-## Query data
-
-```tsx
-import { createPyloHooks } from "@pylo/react";
-import type { PyloSchema } from "@pylo/types";
-
-const { usePyloList, usePyloUpsert } = createPyloHooks<PyloSchema>();
-
-function Contacts() {
-  const { data, isLoading } = usePyloList("contact", {
-    select: { id: true, name: true, company: { select: { name: true } } },
-  });
-
-  const upsert = usePyloUpsert("contact");
-
-  return <List rows={data} onRename={(id, name) => upsert.mutate({ id, name })} />;
-}
-```
-
-For imperative calls outside a query, `usePyloClient<PyloSchema>()` returns the
-same typed client the server SDK exposes.
-
-## Token storage
-
-Tokens live in `localStorage`, which any script running on your page can read.
-Refresh tokens rotate on every use, but a strong Content Security Policy is what
-actually protects them. If your app has a backend, keep the tokens there and
-proxy requests through it instead.
-
-The token is refreshed before it expires and once more if a request comes back
-unauthorized. Only a rejected refresh token ends the session: a transient server
-error leaves it intact, so a backend deploy does not sign everyone out.
-
-## Bringing your own auth
-
-Pass `getToken` instead, and the provider skips login, logout and refresh
-entirely.
-
-```tsx
-<PyloProvider getToken={() => auth.getAccessToken()}>
-```
-
-## Custom storage
-
-`PyloProvider` takes any `PyloStorage`: three async methods for get, set and
-remove.
-
-```ts
-import type { PyloStorage } from "@pylo/react";
-```
+[MIT](./LICENSE)

package/dist/{chunk-IKQ52QLH.js → chunk-BPRHGSZF.js}

@@ -18,7 +18,9 @@ import {
   extractErrorMessage,
   isUnauthorizedError,
   shouldRefreshToken,
+  safeRedirectPath,
   LOGIN_MUTATION,
+  REDEEM_LOGIN_HANDOFF_MUTATION,
   REFRESH_TOKEN_MUTATION
 } from "@pylo/auth";
 function createSessionStore(options) {
@@ -39,19 +41,24 @@ function createSessionStore(options) {
     refreshToken = refresh2;
     await options.storage.setItem(AUTH_KEY, auth);
     await options.storage.setItem(REFRESH_KEY, refresh2);
-    setState({ status: "signedIn", token: auth });
+    setState({ status: "loggedIn", token: auth });
+  }
+  async function startSession(auth, refresh2) {
+    var _a2;
+    await persist(auth, refresh2);
+    (_a2 = options.onLogin) == 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);
+    setState({ status: "loggedOut", token: null });
+    (_a2 = options.onLogout) == null ? void 0 : _a2.call(options);
   }
   async function runRefresh() {
     await init();
-    if (state.status !== "signedIn") return null;
+    if (state.status !== "loggedIn") return null;
     if (!refreshToken) {
       await clear();
       return null;
@@ -81,11 +88,11 @@ function createSessionStore(options) {
         ]);
         refreshToken = stored;
         setState(
-          auth ? { status: "signedIn", token: auth } : { status: "signedOut", token: null }
+          auth ? { status: "loggedIn", token: auth } : { status: "loggedOut", token: null }
         );
       } catch {
         refreshToken = null;
-        setState({ status: "signedOut", token: null });
+        setState({ status: "loggedOut", token: null });
       }
     })();
     return ready;
@@ -111,7 +118,7 @@ function createSessionStore(options) {
     },
     refresh,
     async login(email, password) {
-      var _a2, _b;
+      var _a2;
       const response = await graphqlRequest(
         options.endpoint,
         LOGIN_MUTATION,
@@ -139,14 +146,135 @@ function createSessionStore(options) {
         };
       }
       const { auth_token, refresh_token } = response.data.login.data;
-      await persist(auth_token, refresh_token);
-      (_b = options.onSignIn) == null ? void 0 : _b.call(options);
+      await startSession(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: "LOGIN_FAILED",
+            message: error instanceof Error ? error.message : "Login failed"
+          }
+        };
+      }
+      if (hasErrors(response) || !response.data) {
+        return {
+          success: false,
+          error: {
+            code: "LOGIN_FAILED",
+            message: (_a2 = extractErrorMessage(response.errors)) != null ? _a2 : "Login failed"
+          }
+        };
+      }
+      const { auth_token, refresh_token, redirect } = response.data.redeemLoginHandoff.data;
+      await startSession(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 createSocialLogin(o) {
+  const verifierKey = `${o.keyPrefix}.handoff_verifier`;
+  let completing = null;
+  function redeem(parsed, verifier) {
+    if (!parsed) return failed("LOGIN_FAILED", "No login response in this URL");
+    if ("error" in parsed) return failed("LOGIN_FAILED", parsed.error);
+    if (!verifier) {
+      return failed("LOGIN_FAILED", "No login 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("LOGIN_FAILED", error instanceof Error ? error.message : "Login failed");
+    }
+  }
+  return {
+    async loginWith(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(
+          "LOGIN_FAILED",
+          error instanceof Error ? error.message : "Login failed"
+        );
+      }
+      if (o.openAuthSession) {
+        if (finalUrl === null) return failed("CANCELLED", "Login was cancelled");
+        return redeem(parseHandoffCallback(finalUrl), verifier);
+      }
+      sessionStorage.setItem(verifierKey, verifier);
+      location.assign(startUrl);
+      return new Promise(() => {
+      });
+    },
+    completeLogin(url) {
+      if (o.openAuthSession) {
+        return Promise.resolve(
+          failed("LOGIN_FAILED", "loginWith already completes the login 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();
@@ -246,29 +374,45 @@ function usePyloContext() {
   }
   return value;
 }
-var SIGNED_OUT = { status: "signedOut", token: null };
+var LOGGED_OUT = { status: "loggedOut", token: null };
 var NO_OP = () => () => {
 };
 function PyloProvider(props) {
-  var _a;
+  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"] })
+      onLogout: () => queryClient.clear(),
+      onLogin: () => void queryClient.invalidateQueries({ queryKey: ["pylo"] })
     });
+    if (props.appId !== void 0) {
+      socialRef.current = createSocialLogin({
+        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
+    store ? store.getState : () => LOGGED_OUT,
+    store ? store.getState : () => LOGGED_OUT
   );
   useEffect(() => {
     void (store == null ? void 0 : store.init());
@@ -284,8 +428,8 @@ function PyloProvider(props) {
       getToken,
       ...store ? { onUnauthorized: () => store.refresh() } : {}
     });
-    return { transport, endpoint, state, store, getToken };
-  }, [endpoint, state, store, isEscapeHatch]);
+    return { transport, endpoint, state, store, social, getToken };
+  }, [endpoint, state, store, social, isEscapeHatch]);
   return /* @__PURE__ */ jsx(PyloContext.Provider, { value, children: props.children });
 }
 function usePyloTransport() {
@@ -305,19 +449,19 @@ function usePyloClient() {
   );
 }
 function usePyloAuth() {
-  const { state, store, transport, getToken } = usePyloContext();
-  const isSignedIn = state.status === "signedIn";
+  const { state, store, social, transport, getToken } = usePyloContext();
+  const isLoggedIn = state.status === "loggedIn";
   const me = useQuery({
     queryKey: ["pylo", "me"],
     queryFn: async () => {
       const data = await transport(ME_QUERY, {});
       return data.me.current_user.data;
     },
-    enabled: isSignedIn
+    enabled: isLoggedIn
   });
   return {
-    isLoading: state.status === "loading" || isSignedIn && me.isLoading,
-    isSignedIn,
+    isLoading: state.status === "loading" || isLoggedIn && me.isLoading,
+    isLoggedIn,
     user: me.data,
     login: async (email, password) => {
       if (!store) {
@@ -331,8 +475,17 @@ function usePyloAuth() {
       }
       await store.logout();
     },
+    loginWith: async (provider, options) => requireSocial("loginWith").loginWith(provider, options),
+    completeLogin: async (url) => requireSocial("completeLogin").completeLogin(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 {

package/dist/{chunk-DOPZ5GRU.js → chunk-O456XBDT.js}

@@ -1,6 +1,6 @@
 import {
   usePyloTransport
-} from "./chunk-IKQ52QLH.js";
+} from "./chunk-BPRHGSZF.js";
 
 // src/hooks.ts
 import { useCallback, useRef, useState } from "react";

package/dist/hooks.js

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

package/dist/index.d.ts

@@ -1,16 +1,16 @@
 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-4DBl_6p0.js';
+export { O as OpenAuthSession, b as PyloProvider, c as PyloProviderProps, S as SocialLogin, d as SocialLoginResult, e as createLocalStorageAdapter, f as createMemoryStorage, u as usePyloClient, g as usePyloTransport } from './provider-4DBl_6p0.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';
 import 'react';
 import '@tanstack/react-query';
 
-type SessionStatus = "loading" | "signedIn" | "signedOut";
+type SessionStatus = "loading" | "loggedIn" | "loggedOut";
 interface SessionState {
     status: SessionStatus;
     token: string | null;
@@ -21,9 +21,9 @@ interface SessionStoreOptions {
     appId?: string;
     /** Namespaces the storage keys, for apps holding more than one session. */
     keyPrefix?: string;
-    onSignOut?: () => void;
-    /** Called after a successful login, not after a refresh. */
-    onSignIn?: () => void;
+    onLogout?: () => void;
+    /** Called after a successful login or handoff, not after a refresh. */
+    onLogin?: () => void;
 }
 interface SessionStore {
     getState(): SessionState;
@@ -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 login 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 `loginWith` accepts. Codegen narrows it to those enabled for the app. */
+type RegisteredSocialProvider = PyloRegister extends {
+    socialProvider: infer P extends string;
+} ? P : SocialProvider;
+/** Return URLs `loginWith` 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-O456XBDT.js";
 import {
   PyloProvider,
   createDirectTransport,
@@ -10,10 +10,11 @@ import {
   usePyloAuth,
   usePyloClient,
   usePyloTransport
-} from "./chunk-IKQ52QLH.js";
+} from "./chunk-BPRHGSZF.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-4DBl_6p0.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 SocialLoginResult = AuthResult & {
+    redirect?: string;
+};
+type OpenAuthSession = (url: string, returnUrl: string) => Promise<string | null>;
+interface SocialLogin<P extends string = SocialProvider, U extends string = string> {
+    /**
+     * On the web this navigates away and never resolves; finish on the return page
+     * with `completeLogin`. With `openAuthSession` it resolves once the session ends.
+     */
+    loginWith(provider: P, options: {
+        returnUrl: U;
+        redirect?: string;
+        invite?: string;
+    }): Promise<SocialLoginResult>;
+    /** Finishes a web login from the return page's URL. */
+    completeLogin(url?: string): Promise<SocialLoginResult>;
+}
+
+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 login 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 SocialLogin<P, U> {
+    isLoading: boolean;
+    isLoggedIn: 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 SocialLogin as S, type PyloAuth as a, PyloProvider as b, type PyloProviderProps as c, type SocialLoginResult 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-4DBl_6p0.js';
 import './transport-55cSrvQo.js';

package/dist/provider.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylo/react",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Type-safe React SDK for Pylo — hooks, session provider, client",
   "type": "module",
   "bin": {
@@ -36,8 +36,8 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@pylo/auth": "0.0.6",
-    "@pylo/core": "0.7.0"
+    "@pylo/auth": "0.2.0",
+    "@pylo/core": "0.8.1"
   },
   "peerDependencies": {
     "@tanstack/react-query": ">=5.0.0",
@@ -58,7 +58,7 @@
   ],
   "author": "Okeano GmbH",
   "license": "MIT",
-  "homepage": "https://github.com/Okeano-GmbH/pylo-sdks/tree/main/react#readme",
+  "homepage": "https://docs.pyloapp.com/getting-started/quickstart-react",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Okeano-GmbH/pylo-sdks.git",