@quiltt/react 4.5.1 → 5.0.1

package/dist/index.cjs

@@ -0,0 +1,149 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var client = require('@apollo/client');
+var errors = require('@apollo/client/errors');
+var react = require('@apollo/client/react');
+var react$1 = require('@apollo/client/testing/react');
+var core = require('@quiltt/core');
+var index_cjs = require('./components/index.cjs');
+var index_cjs$1 = require('./hooks/index.cjs');
+var index_cjs$2 = require('./providers/index.cjs');
+
+
+
+Object.defineProperty(exports, "ApolloClient", {
+  enumerable: true,
+  get: function () { return client.ApolloClient; }
+});
+Object.defineProperty(exports, "InMemoryCache", {
+  enumerable: true,
+  get: function () { return client.InMemoryCache; }
+});
+Object.defineProperty(exports, "NetworkStatus", {
+  enumerable: true,
+  get: function () { return client.NetworkStatus; }
+});
+Object.defineProperty(exports, "ObservableQuery", {
+  enumerable: true,
+  get: function () { return client.ObservableQuery; }
+});
+Object.defineProperty(exports, "gql", {
+  enumerable: true,
+  get: function () { return client.gql; }
+});
+Object.defineProperty(exports, "CombinedGraphQLErrors", {
+  enumerable: true,
+  get: function () { return errors.CombinedGraphQLErrors; }
+});
+Object.defineProperty(exports, "CombinedProtocolErrors", {
+  enumerable: true,
+  get: function () { return errors.CombinedProtocolErrors; }
+});
+Object.defineProperty(exports, "LinkError", {
+  enumerable: true,
+  get: function () { return errors.LinkError; }
+});
+Object.defineProperty(exports, "LocalStateError", {
+  enumerable: true,
+  get: function () { return errors.LocalStateError; }
+});
+Object.defineProperty(exports, "ServerError", {
+  enumerable: true,
+  get: function () { return errors.ServerError; }
+});
+Object.defineProperty(exports, "ServerParseError", {
+  enumerable: true,
+  get: function () { return errors.ServerParseError; }
+});
+Object.defineProperty(exports, "UnconventionalError", {
+  enumerable: true,
+  get: function () { return errors.UnconventionalError; }
+});
+Object.defineProperty(exports, "ApolloProvider", {
+  enumerable: true,
+  get: function () { return react.ApolloProvider; }
+});
+Object.defineProperty(exports, "createQueryPreloader", {
+  enumerable: true,
+  get: function () { return react.createQueryPreloader; }
+});
+Object.defineProperty(exports, "skipToken", {
+  enumerable: true,
+  get: function () { return react.skipToken; }
+});
+Object.defineProperty(exports, "useApolloClient", {
+  enumerable: true,
+  get: function () { return react.useApolloClient; }
+});
+Object.defineProperty(exports, "useBackgroundQuery", {
+  enumerable: true,
+  get: function () { return react.useBackgroundQuery; }
+});
+Object.defineProperty(exports, "useFragment", {
+  enumerable: true,
+  get: function () { return react.useFragment; }
+});
+Object.defineProperty(exports, "useLazyQuery", {
+  enumerable: true,
+  get: function () { return react.useLazyQuery; }
+});
+Object.defineProperty(exports, "useLoadableQuery", {
+  enumerable: true,
+  get: function () { return react.useLoadableQuery; }
+});
+Object.defineProperty(exports, "useMutation", {
+  enumerable: true,
+  get: function () { return react.useMutation; }
+});
+Object.defineProperty(exports, "useQuery", {
+  enumerable: true,
+  get: function () { return react.useQuery; }
+});
+Object.defineProperty(exports, "useQueryRefHandlers", {
+  enumerable: true,
+  get: function () { return react.useQueryRefHandlers; }
+});
+Object.defineProperty(exports, "useReactiveVar", {
+  enumerable: true,
+  get: function () { return react.useReactiveVar; }
+});
+Object.defineProperty(exports, "useReadQuery", {
+  enumerable: true,
+  get: function () { return react.useReadQuery; }
+});
+Object.defineProperty(exports, "useSubscription", {
+  enumerable: true,
+  get: function () { return react.useSubscription; }
+});
+Object.defineProperty(exports, "useSuspenseQuery", {
+  enumerable: true,
+  get: function () { return react.useSuspenseQuery; }
+});
+Object.defineProperty(exports, "MockedProvider", {
+  enumerable: true,
+  get: function () { return react$1.MockedProvider; }
+});
+Object.keys(core).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return core[k]; }
+  });
+});
+Object.keys(index_cjs).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return index_cjs[k]; }
+  });
+});
+Object.keys(index_cjs$1).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return index_cjs$1[k]; }
+  });
+});
+Object.keys(index_cjs$2).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return index_cjs$2[k]; }
+  });
+});

package/dist/index.d.ts

@@ -1,217 +1,8 @@
-import { ConnectorSDKCallbacks, Maybe, QuilttJWT, PasscodePayload, UnprocessableData, AuthAPI, UsernamePayload, ConnectorSDKConnectorOptions, InstitutionsData, QuilttClient } from '@quiltt/core';
+export { ApolloClient, ApolloQueryResult, DocumentNode, ErrorPolicy, FetchPolicy, InMemoryCache, NetworkStatus, NormalizedCacheObject, ObservableQuery, OperationVariables, TypedDocumentNode, WatchQueryFetchPolicy, gql } from '@apollo/client';
+export { CombinedGraphQLErrors, CombinedProtocolErrors, LinkError, LocalStateError, ServerError, ServerParseError, UnconventionalError } from '@apollo/client/errors';
+export { ApolloProvider, MutationHookOptions, MutationResult, QueryHookOptions, QueryResult, SubscriptionHookOptions, SubscriptionResult, createQueryPreloader, skipToken, useApolloClient, useBackgroundQuery, useFragment, useLazyQuery, useLoadableQuery, useMutation, useQuery, useQueryRefHandlers, useReactiveVar, useReadQuery, useSubscription, useSuspenseQuery } from '@apollo/client/react';
+export { MockedProvider } from '@apollo/client/testing/react';
 export * from '@quiltt/core';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { JSX, ComponentType, ElementType, PropsWithChildren, MouseEvent, RefObject, useEffect, Dispatch, SetStateAction, FC } from 'react';
-import { useApolloClient } from '@apollo/client/react/hooks/useApolloClient.js';
-
-type PropsOf<Tag> = Tag extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[Tag] : Tag extends ComponentType<infer Props> ? Props & JSX.IntrinsicAttributes : never;
-
-type BaseQuilttButtonProps<T extends ElementType> = {
-    as?: T;
-    connectorId: string;
-    connectionId?: string;
-    institution?: string;
-    /**
-     * Forces complete remount when connectionId changes.
-     * Useful as a fallback for ensuring clean state.
-     * @default false
-     */
-    forceRemountOnConnectionChange?: boolean;
-    onClick?: (event: MouseEvent<HTMLElement>) => void;
-};
-type QuilttCallbackProps = Omit<ConnectorSDKCallbacks, 'onLoad'> & {
-    onLoad?: ConnectorSDKCallbacks['onLoad'];
-    onHtmlLoad?: React.ReactEventHandler<HTMLElement>;
-};
-type QuilttButtonProps<T extends ElementType> = PropsWithChildren<BaseQuilttButtonProps<T> & QuilttCallbackProps>;
-/**
- * QuilttButton provides a clickable interface to open Quiltt connectors.
- *
- * When connectionId changes, the button will automatically update the existing
- * connector instance with the new connection details. If you need to force a
- * complete remount instead, set forceRemountOnConnectionChange to true.
- */
-declare const QuilttButton: <T extends ElementType = "button">({ as, connectorId, connectionId, institution, forceRemountOnConnectionChange, onEvent, onOpen, onLoad, onExit, onExitSuccess, onExitAbort, onExitError, onClick, onHtmlLoad, children, ...props }: QuilttButtonProps<T> & PropsOf<T>) => react_jsx_runtime.JSX.Element;
-
-type QuilttContainerProps<T extends ElementType> = PropsWithChildren<{
-    as?: T;
-    connectorId: string;
-    connectionId?: string;
-    /**
-     * Forces complete remount when connectionId changes.
-     * Useful as a fallback for ensuring clean state.
-     * @default false
-     */
-    forceRemountOnConnectionChange?: boolean;
-} & ConnectorSDKCallbacks>;
-/**
- * QuilttContainer uses globally shared callbacks. It's recommended you only use
- * one Container at a time.
- *
- * When connectionId changes, the container will automatically update the existing
- * connector instance with the new connection details. If you need to force a
- * complete remount instead, set forceRemountOnConnectionChange to true.
- */
-declare const QuilttContainer: <T extends ElementType = "div">({ as, connectorId, connectionId, forceRemountOnConnectionChange, onEvent, onLoad, onExit, onExitSuccess, onExitAbort, onExitError, children, ...props }: QuilttContainerProps<T> & PropsOf<T>) => react_jsx_runtime.JSX.Element;
-
-declare function useEventListener<K extends keyof MediaQueryListEventMap>(eventName: K, handler: (event: MediaQueryListEventMap[K]) => void, element: RefObject<MediaQueryList>, options?: boolean | AddEventListenerOptions): void;
-declare function useEventListener<K extends keyof WindowEventMap>(eventName: K, handler: (event: WindowEventMap[K]) => void, element?: undefined, options?: boolean | AddEventListenerOptions): void;
-declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = HTMLDivElement>(eventName: K, handler: (event: HTMLElementEventMap[K]) => void, element: RefObject<T>, options?: boolean | AddEventListenerOptions): void;
-declare function useEventListener<K extends keyof DocumentEventMap>(eventName: K, handler: (event: DocumentEventMap[K]) => void, element: RefObject<Document>, options?: boolean | AddEventListenerOptions): void;
-
-/**
- * This hook is a browser hook. But React code could be generated from the server without the Window API.
- * This hook switches between useEffect and useLayoutEffect following the execution environment.
- */
-declare const useIsomorphicLayoutEffect: typeof useEffect;
-
-type SetSession = Dispatch<SetStateAction<Maybe<string> | undefined>>;
-/**
- * Custom hook to manage JWT session state with automatic expiration handling.
- * Provides global singleton access to the session across components and windows.
- *
- * TODO: Support Rotation before Expiry
- *
- * Handles two types of data flow:
- * 1. Bottom-up (Login): Token passed through setSession callback
- * 2. Top-down (Refresh): State reinitialized on page reload
- *
- * @param storageKey - Key used for storing session in useStorage (defaults to 'session')
- * @returns [session, setSession] - Current session state and setter function
- */
-declare const useSession: (storageKey?: string) => [Maybe<QuilttJWT> | undefined, SetSession];
-
-type AuthenticateSessionCallbacks = {
-    onSuccess?: () => unknown;
-    onFailure?: () => unknown;
-    onError?: (errors: UnprocessableData) => unknown;
-};
-type AuthenticateSession = (payload: PasscodePayload, callbacks: AuthenticateSessionCallbacks) => Promise<unknown>;
-type UseAuthenticateSession = (auth: AuthAPI, setSession: SetSession) => AuthenticateSession;
-declare const useAuthenticateSession: UseAuthenticateSession;
-
-type IdentifySessionCallbacks = {
-    onSuccess?: () => unknown;
-    onChallenged?: () => unknown;
-    onError?: (errors: UnprocessableData) => unknown;
-    onForbidden?: () => unknown;
-};
-type IdentifySession = (payload: UsernamePayload, callbacks: IdentifySessionCallbacks) => Promise<unknown>;
-type UseIdentifySession = (auth: AuthAPI, setSession: SetSession) => IdentifySession;
-declare const useIdentifySession: UseIdentifySession;
-
-type ImportSession = (token: string) => Promise<boolean>;
-type UseImportSession = (auth: AuthAPI, session: Maybe<QuilttJWT> | undefined, setSession: SetSession, environmentId?: string) => ImportSession;
-/**
- * Optionally Accepts environmentId to validate session is from with your desired environment
- */
-declare const useImportSession: UseImportSession;
-
-type RevokeSession = () => Promise<void>;
-type UseRevokeSession = (auth: AuthAPI, session: Maybe<QuilttJWT> | undefined, setSession: SetSession) => RevokeSession;
-declare const useRevokeSession: UseRevokeSession;
-
-declare const useQuilttClient: typeof useApolloClient;
-
-declare const useQuilttConnector: (connectorId?: string, options?: ConnectorSDKConnectorOptions) => {
-    open: () => void;
-};
-
-type UseQuilttInstitutions = (connectorId: string, onErrorCallback?: (msg: string) => void) => {
-    searchTerm: string;
-    searchResults: InstitutionsData;
-    isSearching: boolean;
-    setSearchTerm: (term: string) => void;
-};
-declare const useQuilttInstitutions: UseQuilttInstitutions;
-
-/**
- * Internal hook that detects when a Quiltt SDK component may be rendered
- * in the same component as QuilttProvider, which is an anti-pattern that
- * can cause memory context issues and unexpected behavior.
- *
- * **Limitation**: Due to React context propagation, this will trigger for ALL
- * descendants of QuilttProvider, not just direct children. This means it may
- * produce false positives for valid nested component patterns. However, the
- * primary use case (same-component rendering) is reliably detected.
- *
- * When the flag is set, this hook will emit a console error. This primarily
- * helps catch the anti-pattern but may also flag valid nested structures.
- *
- * @param componentName - The name of the component calling this hook (for error messages)
- */
-declare const useQuilttRenderGuard: (componentName: string) => void;
-
-type UseQuilttResolvable = (connectorId: string, onErrorCallback?: (msg: string) => void) => {
-    checkResolvable: (providerId: {
-        plaid?: string;
-        mock?: string;
-        mx?: string;
-        finicity?: string;
-        akoya?: string;
-    }) => Promise<boolean | null>;
-    isLoading: boolean;
-    isResolvable: boolean | null;
-    error: string | null;
-};
-declare const useQuilttResolvable: UseQuilttResolvable;
-
-type UseQuilttSession = (environmentId?: string) => {
-    session: Maybe<QuilttJWT> | undefined;
-    importSession: ImportSession;
-    identifySession: IdentifySession;
-    authenticateSession: AuthenticateSession;
-    revokeSession: RevokeSession;
-    forgetSession: (token?: string) => Promise<void>;
-};
-declare const useQuilttSession: UseQuilttSession;
-
-declare const useQuilttSettings: () => {
-    clientId?: string;
-};
-
-/**
- * Attempt to persist state with local storage, so it remains after refresh and
- * across open documents. Falls back to in memory storage when localStorage is
- * unavailable.
- *
- * This hook is used in the same way as useState except that you must pass the
- * storage key in the 1st parameter. If the window object is not present (as in SSR),
- * useStorage() will return the default nextState.
- *
- * Expect values to remain in sync
- *   Across Hooks
- *   Across Reloads
- *   Across Windows (Documents)
- *
- * @param key
- * @param initialState
- * @returns {Array} [storage, setStorage]
- */
-declare const useStorage: <T>(key: string, initialState?: Maybe<T>) => [Maybe<T> | undefined, Dispatch<SetStateAction<Maybe<T> | undefined>>];
-
-type QuilttAuthProviderProps = PropsWithChildren & {
-    /** A custom QuilttClient instance to use instead of the default */
-    graphqlClient?: QuilttClient;
-    /** The Quiltt Session token obtained from the server */
-    token?: string;
-};
-/**
- * If a token is provided, will validate the token against the api and then import
- * it into trusted storage. While this process is happening, the component is put
- * into a loading state and the children are not rendered to prevent race conditions
- * from triggering within the transitionary state.
- */
-declare const QuilttAuthProvider: FC<QuilttAuthProviderProps>;
-
-type QuilttSettingsProviderProps = PropsWithChildren & {
-    /** The Client ID to use for the passwordless Auth API */
-    clientId?: string;
-};
-declare const QuilttSettingsProvider: FC<QuilttSettingsProviderProps>;
-
-type QuilttProviderProps = QuilttSettingsProviderProps & QuilttAuthProviderProps;
-declare const QuilttProvider: FC<QuilttProviderProps>;
-
-export { QuilttAuthProvider, QuilttButton, QuilttContainer, QuilttProvider, QuilttSettingsProvider, useAuthenticateSession, useEventListener, useIdentifySession, useImportSession, useIsomorphicLayoutEffect, useQuilttClient, useQuilttConnector, useQuilttInstitutions, useQuilttRenderGuard, useQuilttResolvable, useQuilttSession, useQuilttSettings, useRevokeSession, useSession, useStorage };
-export type { AuthenticateSession, IdentifySession, ImportSession, QuilttAuthProviderProps, QuilttSettingsProviderProps, RevokeSession, SetSession, UseQuilttInstitutions, UseQuilttResolvable, UseQuilttSession };
+export * from './components/index.js';
+export * from './hooks/index.js';
+export * from './providers/index.js';

package/dist/index.js

@@ -1,192 +1,8 @@
+export { ApolloClient, InMemoryCache, NetworkStatus, ObservableQuery, gql } from '@apollo/client';
+export { CombinedGraphQLErrors, CombinedProtocolErrors, LinkError, LocalStateError, ServerError, ServerParseError, UnconventionalError } from '@apollo/client/errors';
+export { ApolloProvider, createQueryPreloader, skipToken, useApolloClient, useBackgroundQuery, useFragment, useLazyQuery, useLoadableQuery, useMutation, useQuery, useQueryRefHandlers, useReactiveVar, useReadQuery, useSubscription, useSuspenseQuery } from '@apollo/client/react';
+export { MockedProvider } from '@apollo/client/testing/react';
 export * from '@quiltt/core';
-import { jsx } from 'react/jsx-runtime';
-import { useRef, useEffect } from 'react';
-import { u as useQuilttConnector } from './useQuilttConnector-12s-D8VedbrT.js';
-import { u as useQuilttRenderGuard } from './useQuilttRenderGuard-12s-CsS2Ma6Q.js';
-import { i as isDeepEqual, Q as QuilttAuthProvider } from './QuilttAuthProvider-12s-DE-ePRo_.js';
-export { b as useAuthenticateSession, a as useIdentifySession, u as useImportSession, c as useRevokeSession } from './QuilttAuthProvider-12s-DE-ePRo_.js';
-export { u as useEventListener } from './useEventListener-12s-D_-6QIXa.js';
-export { u as useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect-12s-DeTHOKz1.js';
-export { u as useQuilttClient } from './useQuilttClient-12s-CAAUait1.js';
-export { u as useQuilttInstitutions } from './useQuilttInstitutions-12s-DExzPnfb.js';
-export { u as useQuilttResolvable } from './useQuilttResolvable-12s-C0BV3AvR.js';
-export { u as useQuilttSession } from './useQuilttSession-12s-sRvULtJv.js';
-export { u as useQuilttSettings } from './useQuilttSettings-12s--rCJoNHD.js';
-export { u as useSession } from './useSession-12s-7GOn4sUn.js';
-export { u as useStorage } from './useStorage-12s-DHcq3Kuh.js';
-import { Q as QuilttProviderRender } from './QuilttProviderRender-12s-DtQtubjL.js';
-import { Q as QuilttSettingsProvider } from './QuilttSettingsProvider-12s-ZcmFmOiZ.js';
-
-/**
- * QuilttButton provides a clickable interface to open Quiltt connectors.
- *
- * When connectionId changes, the button will automatically update the existing
- * connector instance with the new connection details. If you need to force a
- * complete remount instead, set forceRemountOnConnectionChange to true.
- */ const QuilttButton = ({ as, connectorId, connectionId, institution, forceRemountOnConnectionChange = false, onEvent, onOpen, onLoad, onExit, onExitSuccess, onExitAbort, onExitError, onClick, onHtmlLoad, children, ...props })=>{
-    // Check flag to warn about potential anti-pattern (may produce false positives for valid nested patterns)
-    useQuilttRenderGuard('QuilttButton');
-    // Keep track of previous connectionId for change detection
-    const prevConnectionIdRef = useRef(connectionId);
-    const prevCallbacksRef = useRef({
-        onEvent,
-        onOpen,
-        onLoad,
-        onExit,
-        onExitSuccess,
-        onExitAbort,
-        onExitError
-    });
-    // Track if callbacks have changed to help with debugging
-    const currentCallbacks = {
-        onEvent,
-        onOpen,
-        onLoad,
-        onExit,
-        onExitSuccess,
-        onExitAbort,
-        onExitError
-    };
-    const callbacksChanged = !isDeepEqual(prevCallbacksRef.current, currentCallbacks);
-    useEffect(()=>{
-        prevCallbacksRef.current = currentCallbacks;
-    });
-    // Warning for potential callback reference issues
-    useEffect(()=>{
-        if (callbacksChanged && prevConnectionIdRef.current !== undefined) {
-            console.warn('[Quiltt] Callback functions changed after initial render. ' + 'This may cause unexpected behavior. Consider memoizing callback functions ' + 'with useCallback to maintain stable references.');
-        }
-    }, [
-        callbacksChanged
-    ]);
-    const { open } = useQuilttConnector(connectorId, {
-        connectionId,
-        institution,
-        nonce: props?.nonce,
-        onEvent,
-        onOpen,
-        onLoad,
-        onExit,
-        onExitSuccess,
-        onExitAbort,
-        onExitError
-    });
-    // Update previous connectionId reference
-    useEffect(()=>{
-        prevConnectionIdRef.current = connectionId;
-    }, [
-        connectionId
-    ]);
-    const Button = as || 'button';
-    const handleClick = (event)=>{
-        // Call the user's onClick handler first to allow for:
-        // 1. Pre-open validation
-        // 2. Preventing opening via event.preventDefault()
-        // 3. Setting up state before connector opens
-        onClick?.(event);
-        // Only open if event wasn't prevented
-        if (!event.defaultPrevented) {
-            open();
-        }
-    };
-    // Generate key for forced remounting if enabled, but respect user-provided key
-    const buttonKey = props.key ?? (forceRemountOnConnectionChange ? `${connectorId}-${connectionId || 'no-connection'}` : undefined);
-    return /*#__PURE__*/ jsx(Button, {
-        onClick: handleClick,
-        onLoad: onHtmlLoad,
-        "quiltt-connection": connectionId,
-        ...props,
-        children: children
-    }, buttonKey);
-};
-
-/**
- * QuilttContainer uses globally shared callbacks. It's recommended you only use
- * one Container at a time.
- *
- * When connectionId changes, the container will automatically update the existing
- * connector instance with the new connection details. If you need to force a
- * complete remount instead, set forceRemountOnConnectionChange to true.
- */ const QuilttContainer = ({ as, connectorId, connectionId, forceRemountOnConnectionChange = false, onEvent, onLoad, onExit, onExitSuccess, onExitAbort, onExitError, children, ...props })=>{
-    // Check flag to warn about potential anti-pattern (may produce false positives for valid nested patterns)
-    useQuilttRenderGuard('QuilttContainer');
-    // Keep track of previous connectionId for change detection
-    const prevConnectionIdRef = useRef(connectionId);
-    const prevCallbacksRef = useRef({
-        onEvent,
-        onLoad,
-        onExit,
-        onExitSuccess,
-        onExitAbort,
-        onExitError
-    });
-    // Track if callbacks have changed to help with debugging
-    const currentCallbacks = {
-        onEvent,
-        onLoad,
-        onExit,
-        onExitSuccess,
-        onExitAbort,
-        onExitError
-    };
-    const callbacksChanged = !isDeepEqual(prevCallbacksRef.current, currentCallbacks);
-    useEffect(()=>{
-        prevCallbacksRef.current = currentCallbacks;
-    });
-    // Warning for potential callback reference issues
-    useEffect(()=>{
-        if (callbacksChanged && prevConnectionIdRef.current !== undefined) {
-            console.warn('[Quiltt] Callback functions changed after initial render. ' + 'This may cause unexpected behavior. Consider memoizing callback functions ' + 'with useCallback to maintain stable references.');
-        }
-    }, [
-        callbacksChanged
-    ]);
-    useQuilttConnector(connectorId, {
-        connectionId,
-        nonce: props?.nonce,
-        onEvent,
-        onLoad,
-        onExit,
-        onExitSuccess,
-        onExitAbort,
-        onExitError
-    });
-    // Update previous connectionId reference
-    useEffect(()=>{
-        prevConnectionIdRef.current = connectionId;
-    }, [
-        connectionId
-    ]);
-    const Container = as || 'div';
-    // Generate key for forced remounting if enabled, but respect user-provided key
-    const containerKey = props.key ?? (forceRemountOnConnectionChange ? `${connectorId}-${connectionId || 'no-connection'}` : undefined);
-    return /*#__PURE__*/ jsx(Container, {
-        "quiltt-container": connectorId,
-        "quiltt-connection": connectionId,
-        ...props,
-        children: children
-    }, containerKey);
-};
-
-const QuilttProvider = ({ clientId, graphqlClient, token, children })=>{
-    // Set a context flag that SDK components can check to warn about potential anti-patterns.
-    // LIMITATION: This flags ALL descendants due to React context propagation, not just same-component usage.
-    // Will produce false positives for valid patterns like: <QuilttProvider><MyPage /></QuilttProvider>
-    // where MyPage renders SDK components (which is correct usage).
-    // The flag-based approach is simple but imprecise - a proper solution would require render stack tracking.
-    return /*#__PURE__*/ jsx(QuilttProviderRender.Provider, {
-        value: {
-            isRenderingProvider: true
-        },
-        children: /*#__PURE__*/ jsx(QuilttSettingsProvider, {
-            clientId: clientId,
-            children: /*#__PURE__*/ jsx(QuilttAuthProvider, {
-                token: token,
-                graphqlClient: graphqlClient,
-                children: children
-            })
-        })
-    });
-};
-
-export { QuilttAuthProvider, QuilttButton, QuilttContainer, QuilttProvider, QuilttSettingsProvider, useQuilttConnector, useQuilttRenderGuard };
+export * from './components/index.js';
+export * from './hooks/index.js';
+export * from './providers/index.js';

package/dist/providers/QuilttAuthProvider-12s-CDgQbarX.js

@@ -0,0 +1,60 @@
+'use client';
+import { jsx } from 'react/jsx-runtime';
+import { useRef, useEffect, useMemo } from 'react';
+import { ApolloProvider } from '@apollo/client/react';
+import { QuilttClient, InMemoryCache, createVersionLink } from '@quiltt/core';
+import { useQuilttSession } from '../hooks/index.js';
+import { getPlatformInfo, isDeepEqual } from '../utils/index.js';
+
+/**
+ * If a token is provided, will validate the token against the api and then import
+ * it into trusted storage. While this process is happening, the component is put
+ * into a loading state and the children are not rendered to prevent race conditions
+ * from triggering within the transitionary state.
+ */ const QuilttAuthProvider = ({ graphqlClient, token, children })=>{
+    const { session, importSession } = useQuilttSession();
+    const previousSessionRef = useRef(session);
+    const previousTokenRef = useRef(undefined);
+    const importSessionRef = useRef(importSession);
+    // Keep importSession ref up to date
+    useEffect(()=>{
+        importSessionRef.current = importSession;
+    }, [
+        importSession
+    ]);
+    // Memoize the client to avoid unnecessary re-renders
+    const apolloClient = useMemo(()=>graphqlClient || new QuilttClient({
+            cache: new InMemoryCache(),
+            versionLink: createVersionLink(getPlatformInfo())
+        }), [
+        graphqlClient
+    ]);
+    // Import passed in token (only if value has changed)
+    useEffect(()=>{
+        if (token && token !== previousTokenRef.current) {
+            importSessionRef.current(token);
+            previousTokenRef.current = token;
+        } else if (!token) {
+            // Reset ref when token becomes undefined to allow re-import of same token later
+            previousTokenRef.current = undefined;
+        }
+    }, [
+        token
+    ]);
+    // Reset Client Store when session changes (using deep comparison)
+    useEffect(()=>{
+        if (!isDeepEqual(session, previousSessionRef.current)) {
+            apolloClient.resetStore();
+            previousSessionRef.current = session;
+        }
+    }, [
+        session,
+        apolloClient
+    ]);
+    return /*#__PURE__*/ jsx(ApolloProvider, {
+        client: apolloClient,
+        children: children
+    });
+};
+
+export { QuilttAuthProvider as Q };