@chaosity/location-client-react 0.1.6 → 0.1.7

package/dist/provider/LocationClientProvider.d.ts

@@ -1,10 +1,8 @@
 import type { ReactNode } from 'react';
 import { GeoPlacesClient, ClientConfig } from '@chaosity/location-client';
 interface LocationClientContextValue {
-    config: ClientConfig | null;
     client: GeoPlacesClient | null;
     getToken: () => string | undefined;
-    ensureValidToken: () => Promise<void>;
     loading: boolean;
     error: string | null;
 }
@@ -13,6 +11,7 @@ export interface LocationClientProviderProps {
     getConfig: () => Promise<ClientConfig & {
         expiresAt?: number;
     }>;
+    /** Seconds before expiry to proactively refresh (default: 60) */
     refreshBuffer?: number;
 }
 export declare function LocationClientProvider({ children, getConfig, refreshBuffer }: LocationClientProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/provider/LocationClientProvider.js

@@ -3,95 +3,92 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useEffect, useState, useRef, useCallback } from 'react';
 import { GeoPlacesClient } from '@chaosity/location-client';
 import debug from 'debug';
-import { jwtDecode } from 'jwt-decode';
 const log = debug('location-client-react:provider');
 const LocationClientContext = createContext(undefined);
 export function LocationClientProvider({ children, getConfig, refreshBuffer = 60 }) {
-    const [config, setConfig] = useState(null);
     const [client, setClient] = useState(null);
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(null);
+    // Refs hold live values without triggering re-renders
     const tokenRef = useRef(undefined);
     const expiresAtRef = useRef(null);
     const getConfigRef = useRef(getConfig);
-    const tokenGenerationCount = useRef(0);
-    // Update ref when getConfig changes
+    const refreshPromiseRef = useRef(null);
+    const ensureValidTokenRef = useRef(async () => { });
+    // Keep getConfig ref current without recreating callbacks
     useEffect(() => {
         getConfigRef.current = getConfig;
     }, [getConfig]);
-    // Token getter function (stable reference)
+    // Stable token getter — passed into GeoPlacesClient so it always reads the live ref
     const getToken = useCallback(() => tokenRef.current, []);
-    // Check if token is expired or about to expire
+    // Returns true when the token is expired or within the refresh buffer window.
+    // Treats unknown expiry as expired so we always refresh on first use.
     const isTokenExpired = useCallback(() => {
         if (!expiresAtRef.current)
-            return false;
+            return true;
         return Date.now() >= (expiresAtRef.current - refreshBuffer * 1000);
     }, [refreshBuffer]);
-    // Refresh token if needed
+    // Refreshes the token exactly once even when called concurrently.
+    // All concurrent callers await the same in-flight promise — same pattern as
+    // server-side TokenProvider.tokenPromise deduplication.
     const ensureValidToken = useCallback(async () => {
         if (!isTokenExpired())
             return;
-        const timeUntilExpiry = expiresAtRef.current ? Math.floor((expiresAtRef.current - Date.now()) / 1000) : 0;
-        log('Token expired or expiring soon (expires in %ds), refreshing...', timeUntilExpiry);
-        tokenGenerationCount.current++;
-        try {
+        // Deduplicate: if a refresh is already in flight, wait for it instead of firing another
+        if (refreshPromiseRef.current) {
+            log('Token refresh already in progress, waiting...');
+            return refreshPromiseRef.current;
+        }
+        const timeUntilExpiry = expiresAtRef.current
+            ? Math.floor((expiresAtRef.current - Date.now()) / 1000)
+            : 0;
+        log('Token expired or expiring soon (in %ds), refreshing...', timeUntilExpiry);
+        refreshPromiseRef.current = (async () => {
             const cfg = await getConfigRef.current();
-            setConfig(cfg);
             tokenRef.current = cfg.token;
-            expiresAtRef.current = null;
-            const baseClient = new GeoPlacesClient(cfg);
-            const wrappedClient = new Proxy(baseClient, {
-                get(target, prop) {
-                    if (prop === 'send') {
-                        return async (command) => {
-                            await ensureValidToken();
-                            return target.send(command);
-                        };
-                    }
-                    return target[prop];
-                }
-            });
-            setClient(wrappedClient);
-            const decoded = jwtDecode(cfg.token);
-            expiresAtRef.current = decoded.exp * 1000;
-            const newExpiry = Math.floor((decoded.exp * 1000 - Date.now()) / 1000);
-            log('Token refreshed successfully (new token expires in %ds)', newExpiry);
+            expiresAtRef.current = cfg.expiresAt ?? (Date.now() + 900000);
+            const newExpiry = Math.floor((expiresAtRef.current - Date.now()) / 1000);
+            log('Token refreshed (expires in %ds)', newExpiry);
+        })();
+        try {
+            await refreshPromiseRef.current;
         }
         catch (err) {
             log('Token refresh failed: %s', err instanceof Error ? err.message : 'Unknown error');
             setError(err instanceof Error ? err.message : 'Failed to refresh token');
         }
+        finally {
+            refreshPromiseRef.current = null;
+        }
     }, [isTokenExpired]);
-    // Initial load
+    // Keep ensureValidToken ref current so the send wrapper always uses the latest version
+    useEffect(() => {
+        ensureValidTokenRef.current = ensureValidToken;
+    }, [ensureValidToken]);
+    // Initial load — create the client once.
+    // getToken is passed as a callback so the client always reads the live token ref.
+    // ensureValidToken is called before each send so expiring tokens are refreshed
+    // transparently without recreating the client or causing re-renders.
     useEffect(() => {
         log('Initializing LocationClientProvider');
-        tokenGenerationCount.current++;
-        getConfig()
+        getConfigRef.current()
             .then((cfg) => {
-            setConfig(cfg);
             tokenRef.current = cfg.token;
-            const baseClient = new GeoPlacesClient(cfg);
-            const wrappedClient = new Proxy(baseClient, {
-                get(target, prop) {
-                    if (prop === 'send') {
-                        return async (command) => {
-                            await ensureValidToken();
-                            return target.send(command);
-                        };
-                    }
-                    return target[prop];
-                }
-            });
-            setClient(wrappedClient);
-            try {
-                const decoded = jwtDecode(cfg.token);
-                expiresAtRef.current = decoded.exp * 1000;
-                const expiry = Math.floor((decoded.exp * 1000 - Date.now()) / 1000);
-                log('Client initialized (token expires in %ds)', expiry);
-            }
-            catch (err) {
-                log('Failed to decode token, no expiry info');
-            }
+            expiresAtRef.current = cfg.expiresAt ?? (Date.now() + 900000);
+            // GeoPlacesClient.send() calls getToken() synchronously for the token value,
+            // but token refresh is async. We create a thin send wrapper that:
+            // 1. awaits ensureValidToken (via ref — always latest, race-safe)
+            // 2. delegates to baseClient which reads the now-fresh token from getToken()
+            // The client instance is created once and never recreated on token refresh.
+            const baseClient = new GeoPlacesClient({ apiUrl: cfg.apiUrl, token: cfg.token, getToken });
+            const wrappingClient = Object.create(baseClient);
+            wrappingClient.send = async (command) => {
+                await ensureValidTokenRef.current();
+                return baseClient.send(command);
+            };
+            setClient(wrappingClient);
+            const expiry = Math.floor((expiresAtRef.current - Date.now()) / 1000);
+            log('Client initialized (token expires in %ds)', expiry);
             setLoading(false);
         })
             .catch((err) => {
@@ -99,14 +96,8 @@ export function LocationClientProvider({ children, getConfig, refreshBuffer = 60
             setError(err instanceof Error ? err.message : 'Failed to initialize client');
             setLoading(false);
         });
-    }, [ensureValidToken]);
-    // Check token validity on every state change
-    useEffect(() => {
-        if (!loading && config) {
-            ensureValidToken();
-        }
-    }, [config, loading, ensureValidToken]);
-    return (_jsx(LocationClientContext.Provider, { value: { config, client, getToken, ensureValidToken, loading, error }, children: children }));
+    }, [getToken]);
+    return (_jsx(LocationClientContext.Provider, { value: { client, getToken, loading, error }, children: children }));
 }
 export function useLocationClient() {
     const context = useContext(LocationClientContext);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chaosity/location-client-react",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "React bindings for Chaosity Location Service client",
   "type": "module",
   "main": "dist/index.js",
@@ -8,6 +8,8 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -28,18 +30,24 @@
     "url": "https://github.com/chaosity-io/location-service-client-react/issues"
   },
   "dependencies": {
-    "@chaosity/location-client": "^0.1.5",
-    "debug": "^4.4.3",
-    "jwt-decode": "^4.0.0"
+    "@chaosity/location-client": "file:../location-service-client",
+    "debug": "^4.4.3"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
+    "@testing-library/react": "^16.0.0",
+    "@testing-library/user-event": "^14.0.0",
     "@types/debug": "^4.1.12",
     "@types/react": "^19.0.0",
+    "happy-dom": "^17.0.0",
     "react": "^19.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "files": [
     "dist",