@quiltt/react 5.0.0 → 5.0.2

package/dist/index.d.ts

@@ -1,221 +1,8 @@
 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';
-import { useApolloClient } from '@apollo/client/react';
 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';
-import { ConnectorSDKCallbacks, Maybe, QuilttJWT, PasscodePayload, UnprocessableData, AuthAPI, UsernamePayload, ConnectorSDKConnectorOptions, InstitutionsData, QuilttClient } from '@quiltt/core';
 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';
-
-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

@@ -3,193 +3,6 @@ export { CombinedGraphQLErrors, CombinedProtocolErrors, LinkError, LocalStateErr
 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 { i as isDeepEqual, u as useQuilttConnector } from './useQuilttConnector-12s-DfCZ1lpS.js';
-import { u as useQuilttRenderGuard } from './useQuilttRenderGuard-12s-CsS2Ma6Q.js';
-export { u as useEventListener } from './useEventListener-12s-D_-6QIXa.js';
-export { u as useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect-12s-DeTHOKz1.js';
-export { a as useAuthenticateSession, b as useIdentifySession, c as useImportSession, u as useQuilttSession, d as useRevokeSession } from './useQuilttSession-12s-_8sB_8aP.js';
-export { u as useQuilttClient } from './useQuilttClient-12s-Dj_MtYTU.js';
-export { u as useQuilttInstitutions } from './useQuilttInstitutions-12s-ClSQJPmP.js';
-export { u as useQuilttResolvable } from './useQuilttResolvable-12s-Dm4vsARj.js';
-export { u as useQuilttSettings } from './useQuilttSettings-12s--rCJoNHD.js';
-export { u as useSession } from './useSession-12s-BlrWOArd.js';
-export { u as useStorage } from './useStorage-12s-CpG6X57D.js';
-import { Q as QuilttAuthProvider } from './QuilttAuthProvider-12s-C_Wt9rkK.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/{QuilttAuthProvider-12s-C_Wt9rkK.js → providers/QuilttAuthProvider-12s-CDgQbarX.js}

@@ -1,14 +1,10 @@
 'use client';
-import { useRef, useMemo, useEffect } from 'react';
-import { QuilttClient, InMemoryCache, createVersionLink } from '@quiltt/core';
-import { ApolloProvider } from '@apollo/client/react';
-import './QuilttSettings-12s-BK-0SQME.js';
-import './useSession-12s-BlrWOArd.js';
-import 'use-debounce';
-import './QuilttProviderRender-12s-DtQtubjL.js';
 import { jsx } from 'react/jsx-runtime';
-import { u as useQuilttSession } from './useQuilttSession-12s-_8sB_8aP.js';
-import { a as getPlatformInfo, i as isDeepEqual } from './useQuilttConnector-12s-DfCZ1lpS.js';
+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
@@ -19,6 +15,13 @@ import { a as getPlatformInfo, i as isDeepEqual } from './useQuilttConnector-12s
     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(),
@@ -29,15 +32,14 @@ import { a as getPlatformInfo, i as isDeepEqual } from './useQuilttConnector-12s
     // Import passed in token (only if value has changed)
     useEffect(()=>{
         if (token && token !== previousTokenRef.current) {
-            importSession(token);
+            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,
-        importSession
+        token
     ]);
     // Reset Client Store when session changes (using deep comparison)
     useEffect(()=>{

package/dist/providers/QuilttAuthProvider-12s-D__FY1Qn.cjs

@@ -0,0 +1,60 @@
+'use client';
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var react$1 = require('@apollo/client/react');
+var core = require('@quiltt/core');
+var index_cjs = require('../hooks/index.cjs');
+var index_cjs$1 = require('../utils/index.cjs');
+
+/**
+ * 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 } = index_cjs.useQuilttSession();
+    const previousSessionRef = react.useRef(session);
+    const previousTokenRef = react.useRef(undefined);
+    const importSessionRef = react.useRef(importSession);
+    // Keep importSession ref up to date
+    react.useEffect(()=>{
+        importSessionRef.current = importSession;
+    }, [
+        importSession
+    ]);
+    // Memoize the client to avoid unnecessary re-renders
+    const apolloClient = react.useMemo(()=>graphqlClient || new core.QuilttClient({
+            cache: new core.InMemoryCache(),
+            versionLink: core.createVersionLink(index_cjs$1.getPlatformInfo())
+        }), [
+        graphqlClient
+    ]);
+    // Import passed in token (only if value has changed)
+    react.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)
+    react.useEffect(()=>{
+        if (!index_cjs$1.isDeepEqual(session, previousSessionRef.current)) {
+            apolloClient.resetStore();
+            previousSessionRef.current = session;
+        }
+    }, [
+        session,
+        apolloClient
+    ]);
+    return /*#__PURE__*/ jsxRuntime.jsx(react$1.ApolloProvider, {
+        client: apolloClient,
+        children: children
+    });
+};
+
+exports.QuilttAuthProvider = QuilttAuthProvider;

package/dist/providers/QuilttProviderRender-12s-DtQtubjL.js

@@ -0,0 +1,6 @@
+'use client';
+import { createContext } from 'react';
+
+const QuilttProviderRender = createContext({});
+
+export { QuilttProviderRender as Q };

package/dist/providers/QuilttProviderRender-12s-pvnc98Lj.cjs

@@ -0,0 +1,6 @@
+'use client';
+var react = require('react');
+
+const QuilttProviderRender = react.createContext({});
+
+exports.QuilttProviderRender = QuilttProviderRender;

package/dist/providers/QuilttSettings-12s-BK-0SQME.js

@@ -0,0 +1,6 @@
+'use client';
+import { createContext } from 'react';
+
+const QuilttSettings = createContext({});
+
+export { QuilttSettings as Q };

package/dist/providers/QuilttSettings-12s-cLPT_GLC.cjs

@@ -0,0 +1,6 @@
+'use client';
+var react = require('react');
+
+const QuilttSettings = react.createContext({});
+
+exports.QuilttSettings = QuilttSettings;

package/dist/providers/QuilttSettingsProvider-12s-D7e8dsOE.cjs

@@ -0,0 +1,19 @@
+'use client';
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var QuilttSettings12s = require('./QuilttSettings-12s-cLPT_GLC.cjs');
+
+const QuilttSettingsProvider = ({ clientId, children })=>{
+    // Memoize context value to prevent unnecessary re-renders
+    const contextValue = react.useMemo(()=>({
+            clientId
+        }), [
+        clientId
+    ]);
+    return /*#__PURE__*/ jsxRuntime.jsx(QuilttSettings12s.QuilttSettings.Provider, {
+        value: contextValue,
+        children: children
+    });
+};
+
+exports.QuilttSettingsProvider = QuilttSettingsProvider;

package/dist/{QuilttSettingsProvider-12s-ZcmFmOiZ.js → providers/QuilttSettingsProvider-12s-DND2gPQm.js}

@@ -1,14 +1,17 @@
 'use client';
 import { jsx } from 'react/jsx-runtime';
-import { useState } from 'react';
+import { useMemo } from 'react';
 import { Q as QuilttSettings } from './QuilttSettings-12s-BK-0SQME.js';
 
 const QuilttSettingsProvider = ({ clientId, children })=>{
-    const [_clientId] = useState(clientId);
+    // Memoize context value to prevent unnecessary re-renders
+    const contextValue = useMemo(()=>({
+            clientId
+        }), [
+        clientId
+    ]);
     return /*#__PURE__*/ jsx(QuilttSettings.Provider, {
-        value: {
-            clientId: _clientId
-        },
+        value: contextValue,
         children: children
     });
 };

package/dist/providers/index.cjs

@@ -0,0 +1,34 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var QuilttAuthProvider12s = require('./QuilttAuthProvider-12s-D__FY1Qn.cjs');
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var QuilttProviderRender12s = require('./QuilttProviderRender-12s-pvnc98Lj.cjs');
+var QuilttSettingsProvider12s = require('./QuilttSettingsProvider-12s-D7e8dsOE.cjs');
+
+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.
+    // Memoize context value to prevent unnecessary re-renders
+    const renderContextValue = react.useMemo(()=>({
+            isRenderingProvider: true
+        }), []);
+    return /*#__PURE__*/ jsxRuntime.jsx(QuilttProviderRender12s.QuilttProviderRender.Provider, {
+        value: renderContextValue,
+        children: /*#__PURE__*/ jsxRuntime.jsx(QuilttSettingsProvider12s.QuilttSettingsProvider, {
+            clientId: clientId,
+            children: /*#__PURE__*/ jsxRuntime.jsx(QuilttAuthProvider12s.QuilttAuthProvider, {
+                token: token,
+                graphqlClient: graphqlClient,
+                children: children
+            })
+        })
+    });
+};
+
+exports.QuilttAuthProvider = QuilttAuthProvider12s.QuilttAuthProvider;
+exports.QuilttSettingsProvider = QuilttSettingsProvider12s.QuilttSettingsProvider;
+exports.QuilttProvider = QuilttProvider;