@quiltt/react 4.5.1 → 5.0.1

package/dist/components/useScript-12s-CMIDUHrx.cjs

@@ -0,0 +1,92 @@
+'use client';
+var react = require('react');
+
+// Cached script statuses
+const cachedScriptStatuses = {};
+function getScriptNode(src) {
+    const node = document.querySelector(`script[src="${src}"]`);
+    const status = node?.getAttribute('data-status');
+    return {
+        node,
+        status
+    };
+}
+// @see https://usehooks-ts.com/react-hook/use-script
+function useScript(src, options) {
+    const [status, setStatus] = react.useState(()=>{
+        if (!src || options?.shouldPreventLoad) {
+            return 'idle';
+        }
+        if (typeof window === 'undefined') {
+            // SSR Handling - always return 'loading'
+            return 'loading';
+        }
+        return cachedScriptStatuses[src] ?? 'loading';
+    });
+    react.useEffect(()=>{
+        if (!src || options?.shouldPreventLoad) {
+            return;
+        }
+        const cachedScriptStatus = cachedScriptStatuses[src];
+        if (cachedScriptStatus === 'ready' || cachedScriptStatus === 'error') {
+            // If the script is already cached, set its status immediately
+            setStatus(cachedScriptStatus);
+            return;
+        }
+        // Fetch existing script element by src
+        // It may have been added by another instance of this hook
+        const script = getScriptNode(src);
+        let scriptNode = script.node;
+        if (!scriptNode) {
+            // Create script element and add it to document body
+            scriptNode = document.createElement('script');
+            scriptNode.src = src;
+            scriptNode.async = true;
+            if (options?.nonce && options.nonce.trim() !== '') {
+                scriptNode.nonce = options.nonce;
+            }
+            scriptNode.setAttribute('data-status', 'loading');
+            document.body.appendChild(scriptNode);
+            // Store status in attribute on script
+            // This can be read by other instances of this hook
+            const setAttributeFromEvent = (event)=>{
+                const scriptStatus = event.type === 'load' ? 'ready' : 'error';
+                scriptNode?.setAttribute('data-status', scriptStatus);
+            };
+            scriptNode.addEventListener('load', setAttributeFromEvent);
+            scriptNode.addEventListener('error', setAttributeFromEvent);
+        } else {
+            // Grab existing script status from attribute and set to state.
+            setStatus(script.status ?? cachedScriptStatus ?? 'loading');
+        }
+        // Script event handler to update status in state
+        // Note: Even if the script already exists we still need to add
+        // event handlers to update the state for *this* hook instance.
+        const setStateFromEvent = (event)=>{
+            const newStatus = event.type === 'load' ? 'ready' : 'error';
+            setStatus(newStatus);
+            cachedScriptStatuses[src] = newStatus;
+        };
+        // Add event listeners
+        scriptNode.addEventListener('load', setStateFromEvent);
+        scriptNode.addEventListener('error', setStateFromEvent);
+        // Remove event listeners on cleanup
+        return ()=>{
+            if (scriptNode) {
+                scriptNode.removeEventListener('load', setStateFromEvent);
+                scriptNode.removeEventListener('error', setStateFromEvent);
+            }
+            if (scriptNode && options?.removeOnUnmount) {
+                scriptNode.remove();
+            }
+        };
+    }, [
+        src,
+        options?.shouldPreventLoad,
+        options?.nonce,
+        options?.removeOnUnmount
+    ]);
+    return status;
+}
+
+exports.useScript = useScript;

package/dist/{useSession-12s-7GOn4sUn.js → components/useSession-12s-BNPsfKY-.js}

@@ -1,7 +1,7 @@
 'use client';
 import { useMemo, useEffect, useCallback } from 'react';
 import { Timeoutable, JsonWebTokenParse } from '@quiltt/core';
-import { u as useStorage } from './useStorage-12s-DHcq3Kuh.js';
+import { u as useStorage } from './useStorage-12s-CpG6X57D.js';
 
 // Initialize JWT parser with our specific claims type
 const parse = JsonWebTokenParse;
@@ -30,14 +30,35 @@ const sessionTimer = new Timeoutable();
         if (!session) return;
         const expirationMS = session.claims.exp * 1000;
         const expire = ()=>setToken(null);
+        const checkExpiration = ()=>{
+            if (Date.now() >= expirationMS) {
+                expire();
+                return true;
+            }
+            return false;
+        };
         // Clear immediately if already expired
-        if (Date.now() >= expirationMS) {
-            expire();
-        } else {
-            // Set timer to clear session at expiration time
-            sessionTimer.set(expire, expirationMS - Date.now());
-            return ()=>sessionTimer.clear(expire);
+        if (checkExpiration()) {
+            return;
         }
+        // Set timer to clear session at expiration time
+        sessionTimer.set(expire, expirationMS - Date.now());
+        // Also check expiration when tab becomes visible (handles idle sessions)
+        const handleVisibilityChange = ()=>{
+            if (!document.hidden) {
+                checkExpiration();
+            }
+        };
+        // Only add listener in browser environment
+        if (typeof document !== 'undefined') {
+            document.addEventListener('visibilitychange', handleVisibilityChange);
+        }
+        return ()=>{
+            sessionTimer.clear(expire);
+            if (typeof document !== 'undefined') {
+                document.removeEventListener('visibilitychange', handleVisibilityChange);
+            }
+        };
     }, [
         session,
         setToken

package/dist/components/useSession-12s-BNotXj5T.cjs

@@ -0,0 +1,90 @@
+'use client';
+var react = require('react');
+var core = require('@quiltt/core');
+var useStorage12s = require('./useStorage-12s-D7nllsrI.cjs');
+
+// Initialize JWT parser with our specific claims type
+const parse = core.JsonWebTokenParse;
+// Global timer to manage token expiration across all hook instances
+const sessionTimer = new core.Timeoutable();
+/**
+ * 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
+ */ const useSession = (storageKey = 'session')=>{
+    const [token, setToken] = useStorage12s.useStorage(storageKey);
+    // Parse token into session data, updates when token changes
+    const session = react.useMemo(()=>parse(token), [
+        token
+    ]);
+    // Handle session expiration
+    react.useEffect(()=>{
+        if (!session) return;
+        const expirationMS = session.claims.exp * 1000;
+        const expire = ()=>setToken(null);
+        const checkExpiration = ()=>{
+            if (Date.now() >= expirationMS) {
+                expire();
+                return true;
+            }
+            return false;
+        };
+        // Clear immediately if already expired
+        if (checkExpiration()) {
+            return;
+        }
+        // Set timer to clear session at expiration time
+        sessionTimer.set(expire, expirationMS - Date.now());
+        // Also check expiration when tab becomes visible (handles idle sessions)
+        const handleVisibilityChange = ()=>{
+            if (!document.hidden) {
+                checkExpiration();
+            }
+        };
+        // Only add listener in browser environment
+        if (typeof document !== 'undefined') {
+            document.addEventListener('visibilitychange', handleVisibilityChange);
+        }
+        return ()=>{
+            sessionTimer.clear(expire);
+            if (typeof document !== 'undefined') {
+                document.removeEventListener('visibilitychange', handleVisibilityChange);
+            }
+        };
+    }, [
+        session,
+        setToken
+    ]);
+    /**
+   * Validates and updates the session token.
+   * - Handles both direct values and updater functions
+   * - Validates new tokens before setting them
+   * - Prevents unnecessary updates for same token value
+   * - Allows clearing the session with null/undefined
+   */ const setSession = react.useCallback((nextState)=>{
+        const newState = nextState instanceof Function ? nextState(token) : nextState;
+        // Only update if:
+        // 1. The token has actually changed AND
+        // 2. Either the new state is falsy (clearing session) OR it's a valid token
+        if (token !== newState && (!newState || parse(newState))) {
+            setToken(newState);
+        }
+    }, [
+        token,
+        setToken
+    ]);
+    return [
+        session,
+        setSession
+    ];
+};
+
+exports.useSession = useSession;

package/dist/{useStorage-12s-DHcq3Kuh.js → components/useStorage-12s-CpG6X57D.js}

@@ -43,24 +43,14 @@ import { GlobalStorage } from '@quiltt/core';
         hookState
     ]);
     useEffect(()=>{
-        // Subscribe to storage changes and ensure state is synchronized
-        // Reruns when key or state changes to maintain consistency
-        GlobalStorage.subscribe(key, (newValue)=>{
-            // Only update if the value is different from current state
-            if (newValue !== hookState) {
-                setHookState(newValue);
-            }
-        });
-        // Initial sync
-        const initialValue = getStorage();
-        if (initialValue !== hookState) {
-            setHookState(initialValue);
-        }
-        return ()=>GlobalStorage.unsubscribe(key, setHookState);
+        // Subscribe to storage changes from other sources (e.g., other hook instances, browser tabs)
+        const handleStorageChange = (newValue)=>{
+            setHookState(newValue);
+        };
+        GlobalStorage.subscribe(key, handleStorageChange);
+        return ()=>GlobalStorage.unsubscribe(key, handleStorageChange);
     }, [
-        key,
-        hookState,
-        getStorage
+        key
     ]);
     return [
         hookState,

package/dist/components/useStorage-12s-D7nllsrI.cjs

@@ -0,0 +1,61 @@
+'use client';
+var react = require('react');
+var core = require('@quiltt/core');
+
+/**
+ * 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]
+ */ const useStorage = (key, initialState)=>{
+    const getStorage = react.useCallback(()=>{
+        const state = core.GlobalStorage.get(key);
+        if (state !== undefined) {
+            return state;
+        }
+        return initialState;
+    }, [
+        key,
+        initialState
+    ]);
+    const [hookState, setHookState] = react.useState(getStorage());
+    const setStorage = react.useCallback((nextState)=>{
+        const newState = nextState instanceof Function ? nextState(hookState) : nextState;
+        if (hookState !== newState) {
+            core.GlobalStorage.set(key, newState);
+            // Immediately update hook state as well
+            setHookState(newState);
+        }
+    }, [
+        key,
+        hookState
+    ]);
+    react.useEffect(()=>{
+        // Subscribe to storage changes from other sources (e.g., other hook instances, browser tabs)
+        const handleStorageChange = (newValue)=>{
+            setHookState(newValue);
+        };
+        core.GlobalStorage.subscribe(key, handleStorageChange);
+        return ()=>core.GlobalStorage.unsubscribe(key, handleStorageChange);
+    }, [
+        key
+    ]);
+    return [
+        hookState,
+        setStorage
+    ];
+};
+
+exports.useStorage = useStorage;

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

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

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

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

package/dist/contexts/index.cjs

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var QuilttSettings12s = require('./QuilttSettings-12s-cLPT_GLC.cjs');
+
+
+
+exports.QuilttSettings = QuilttSettings12s.QuilttSettings;

package/dist/contexts/index.d.ts

@@ -0,0 +1,8 @@
+import * as react from 'react';
+
+type QuilttSettingsContext = {
+    clientId?: string;
+};
+declare const QuilttSettings: react.Context<QuilttSettingsContext>;
+
+export { QuilttSettings };

package/dist/contexts/index.js

@@ -0,0 +1 @@
+export { Q as QuilttSettings } from './QuilttSettings-12s-BK-0SQME.js';

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

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

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

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

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

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

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

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

package/dist/hooks/index.cjs

@@ -0,0 +1,31 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useEventListener12s = require('./useEventListener-12s-CV8cLxWu.cjs');
+var useIsomorphicLayoutEffect12s = require('./useIsomorphicLayoutEffect-12s-B8KjaroI.cjs');
+var useQuilttSession12s = require('./useQuilttSession-12s-C8kq5S2Y.cjs');
+var useQuilttClient12s = require('./useQuilttClient-12s-flQYSVdG.cjs');
+var useQuilttConnector12s = require('./useQuilttConnector-12s-D51PZPgm.cjs');
+var useQuilttInstitutions12s = require('./useQuilttInstitutions-12s-D_Kr43s3.cjs');
+var useQuilttRenderGuard12s = require('./useQuilttRenderGuard-12s-D9WbRzZO.cjs');
+var useQuilttResolvable12s = require('./useQuilttResolvable-12s-D8wnfNBt.cjs');
+var useQuilttSettings12s = require('./useQuilttSettings-12s-aDLXY6z3.cjs');
+var useSession12s = require('./useSession-12s-BNotXj5T.cjs');
+var useStorage12s = require('./useStorage-12s-D7nllsrI.cjs');
+
+
+
+exports.useEventListener = useEventListener12s.useEventListener;
+exports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect12s.useIsomorphicLayoutEffect;
+exports.useAuthenticateSession = useQuilttSession12s.useAuthenticateSession;
+exports.useIdentifySession = useQuilttSession12s.useIdentifySession;
+exports.useImportSession = useQuilttSession12s.useImportSession;
+exports.useQuilttSession = useQuilttSession12s.useQuilttSession;
+exports.useRevokeSession = useQuilttSession12s.useRevokeSession;
+exports.useQuilttClient = useQuilttClient12s.useQuilttClient;
+exports.useQuilttConnector = useQuilttConnector12s.useQuilttConnector;
+exports.useQuilttInstitutions = useQuilttInstitutions12s.useQuilttInstitutions;
+exports.useQuilttRenderGuard = useQuilttRenderGuard12s.useQuilttRenderGuard;
+exports.useQuilttResolvable = useQuilttResolvable12s.useQuilttResolvable;
+exports.useQuilttSettings = useQuilttSettings12s.useQuilttSettings;
+exports.useSession = useSession12s.useSession;
+exports.useStorage = useStorage12s.useStorage;

package/dist/hooks/index.d.ts

@@ -0,0 +1,142 @@
+import { RefObject, useEffect, Dispatch, SetStateAction } from 'react';
+import { Maybe, QuilttJWT, PasscodePayload, UnprocessableData, AuthAPI, UsernamePayload, ConnectorSDKConnectorOptions, InstitutionsData } from '@quiltt/core';
+import { useApolloClient } from '@apollo/client/react';
+
+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>>];
+
+export { useAuthenticateSession, useEventListener, useIdentifySession, useImportSession, useIsomorphicLayoutEffect, useQuilttClient, useQuilttConnector, useQuilttInstitutions, useQuilttRenderGuard, useQuilttResolvable, useQuilttSession, useQuilttSettings, useRevokeSession, useSession, useStorage };
+export type { AuthenticateSession, IdentifySession, ImportSession, RevokeSession, SetSession, UseQuilttInstitutions, UseQuilttResolvable, UseQuilttSession };

package/dist/hooks/index.js

@@ -0,0 +1,11 @@
+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-DQFfjmob.js';
+export { u as useQuilttClient } from './useQuilttClient-12s-Dj_MtYTU.js';
+export { u as useQuilttConnector } from './useQuilttConnector-12s-C0KJHuZN.js';
+export { u as useQuilttInstitutions } from './useQuilttInstitutions-12s-rgLHD9ye.js';
+export { u as useQuilttRenderGuard } from './useQuilttRenderGuard-12s-CsS2Ma6Q.js';
+export { u as useQuilttResolvable } from './useQuilttResolvable-12s-BUDeH696.js';
+export { u as useQuilttSettings } from './useQuilttSettings-12s--rCJoNHD.js';
+export { u as useSession } from './useSession-12s-BNPsfKY-.js';
+export { u as useStorage } from './useStorage-12s-CpG6X57D.js';

package/dist/hooks/useEventListener-12s-CV8cLxWu.cjs

@@ -0,0 +1,34 @@
+'use client';
+var react = require('react');
+var useIsomorphicLayoutEffect12s = require('./useIsomorphicLayoutEffect-12s-B8KjaroI.cjs');
+
+/**
+ * Supports Window, Element and Document and custom events with almost
+ * the same parameters as the native addEventListener options.
+ */ function useEventListener(eventName, handler, element, options) {
+    // Create a ref that stores handler
+    const savedHandler = react.useRef(handler);
+    useIsomorphicLayoutEffect12s.useIsomorphicLayoutEffect(()=>{
+        savedHandler.current = handler;
+    }, [
+        handler
+    ]);
+    react.useEffect(()=>{
+        // Define the listening target
+        const targetElement = element?.current ?? window;
+        if (!targetElement?.addEventListener) return;
+        // Create event listener that calls handler function stored in ref
+        const listener = (event)=>savedHandler.current(event);
+        targetElement.addEventListener(eventName, listener, options);
+        // Remove event listener on cleanup
+        return ()=>{
+            targetElement.removeEventListener(eventName, listener, options);
+        };
+    }, [
+        eventName,
+        element,
+        options
+    ]);
+}
+
+exports.useEventListener = useEventListener;

package/dist/hooks/useIsomorphicLayoutEffect-12s-B8KjaroI.cjs

@@ -0,0 +1,9 @@
+'use client';
+var react = require('react');
+
+/**
+ * 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.
+ */ const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? react.useLayoutEffect : react.useEffect;
+
+exports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;

package/dist/{useQuilttClient-12s-CAAUait1.js → hooks/useQuilttClient-12s-Dj_MtYTU.js}

@@ -1,5 +1,5 @@
 'use client';
-import { useApolloClient } from '@apollo/client/react/hooks/useApolloClient.js';
+import { useApolloClient } from '@apollo/client/react';
 
 const useQuilttClient = useApolloClient;
 

package/dist/hooks/useQuilttClient-12s-flQYSVdG.cjs

@@ -0,0 +1,6 @@
+'use client';
+var react = require('@apollo/client/react');
+
+const useQuilttClient = react.useApolloClient;
+
+exports.useQuilttClient = useQuilttClient;