@poly-x/react 0.1.0-alpha.16 → 0.1.0-alpha.17

package/dist/index.cjs

@@ -515,43 +515,68 @@ function Protected({ children, fallback = null, loading = null }) {
 }
 //#endregion
 //#region src/geolocation.ts
-/**
-* Capture the browser's precise location IF the user consented. Resolves to a consent-labelled
-* result and never throws/rejects.
-*/
-async function capturePreciseLocation(consented, opts = {}) {
-	if (!consented) return { consent: "denied" };
-	const geo = opts.geolocation ?? (typeof navigator !== "undefined" ? navigator.geolocation : void 0);
-	if (!geo) return { consent: "denied" };
-	const timeoutMs = opts.timeoutMs ?? 8e3;
+/** W3C Geolocation `PositionError.PERMISSION_DENIED`. The only code that means a real "no". */
+const PERMISSION_DENIED = 1;
+/** One capture attempt at a given accuracy. Never rejects. */
+function attemptCapture(geo, highAccuracy, timeout) {
 	return new Promise((resolve) => {
 		let settled = false;
-		const done = (result) => {
+		const done = (outcome) => {
 			if (settled) return;
 			settled = true;
-			resolve(result);
+			resolve(outcome);
 		};
-		const timer = setTimeout(() => done({ consent: "denied" }), timeoutMs + 500);
-		const finish = (result) => {
+		const timer = setTimeout(() => done({
+			result: { consent: "granted" },
+			retriable: true
+		}), timeout + 1500);
+		const finish = (outcome) => {
 			clearTimeout(timer);
-			done(result);
+			done(outcome);
 		};
 		try {
 			geo.getCurrentPosition((position) => finish({
-				latitude: String(position.coords.latitude),
-				longitude: String(position.coords.longitude),
-				accuracyMeters: typeof position.coords.accuracy === "number" ? position.coords.accuracy : void 0,
-				consent: "granted"
-			}), () => finish({ consent: "denied" }), {
-				enableHighAccuracy: true,
-				timeout: timeoutMs,
+				result: {
+					latitude: String(position.coords.latitude),
+					longitude: String(position.coords.longitude),
+					accuracyMeters: typeof position.coords.accuracy === "number" ? position.coords.accuracy : void 0,
+					consent: "granted"
+				},
+				retriable: false
+			}), (err) => {
+				const code = err?.code;
+				const denied = typeof code === "number" && code === PERMISSION_DENIED;
+				finish({
+					result: { consent: denied ? "denied" : "granted" },
+					retriable: !denied
+				});
+			}, {
+				enableHighAccuracy: highAccuracy,
+				timeout,
 				maximumAge: 0
 			});
 		} catch {
-			finish({ consent: "denied" });
+			finish({
+				result: { consent: "granted" },
+				retriable: true
+			});
 		}
 	});
 }
+/**
+* Capture the browser's precise location. Resolves to a consent-labelled result and never
+* throws/rejects. High-accuracy first; on a no-fix (not a denial) retries once at low accuracy.
+*/
+async function capturePreciseLocation(consented, opts = {}) {
+	if (!consented) return { consent: "denied" };
+	const geo = opts.geolocation ?? (typeof navigator !== "undefined" ? navigator.geolocation : void 0);
+	if (!geo) return { consent: "denied" };
+	const highAccuracyMs = opts.timeoutMs ?? 8e3;
+	const lowAccuracyMs = opts.fallbackTimeoutMs ?? 12e3;
+	const first = await attemptCapture(geo, true, highAccuracyMs);
+	if (first.result.latitude !== void 0 || !first.retriable) return first.result;
+	return (await attemptCapture(geo, false, lowAccuracyMs)).result;
+}
 //#endregion
 //#region src/components/sign-in.tsx
 const DEFAULT_LABELS$3 = {

package/dist/index.d.cts

@@ -410,11 +410,17 @@ declare function AuthCallback({
 /**
  * @poly-x/react/geolocation — browser precise-location capture for sign-in (v6, FR-CNST/FR-LOC).
  *
- * The consent-gated bridge to `navigator.geolocation`. It NEVER rejects: a decline, a browser
- * permission denial, a missing API, or a timeout all resolve to `{ consent: "denied" }` with no
- * coordinates, so the caller can always proceed — sign-in must never block on location (D52).
- * The captured value is posted to the BFF, which forwards it to the platform on the token
- * exchange; the platform stores precise only when consent is `granted`, else coarse (IP).
+ * The consent-gated bridge to `navigator.geolocation`. It NEVER rejects: a missing API resolves
+ * to `{ consent: "denied" }` with no coordinates so the caller can always proceed — sign-in must
+ * never block on location (D52).
+ *
+ * Consent vs. fix are kept SEPARATE. `consent` reflects the browser PERMISSION decision only:
+ * `denied` means the user actually said no (`PERMISSION_DENIED`). A position that is merely
+ * unavailable or times out (common on desktops with no GPS) is NOT a denial — the user consented,
+ * we just couldn't get coordinates, so consent stays `granted` with no coords and the platform
+ * uses the coarse (IP) fallback. Conflating the two is why an allowed login could be stored as
+ * `denied` + coarse. On a no-fix (not a denial) we retry once at low accuracy (network-based),
+ * which is far more reliable than high-accuracy GPS on desktop browsers.
  */
 /** Minimal shape of the browser Geolocation API we depend on (injectable for testing). */
 interface GeolocationLike {
@@ -424,28 +430,33 @@ interface GeolocationLike {
       longitude: number;
       accuracy?: number;
     };
-  }) => void, error?: (err: unknown) => void, options?: {
+  }) => void, error?: (err: {
+    code?: number;
+  } | unknown) => void, options?: {
     enableHighAccuracy?: boolean;
     timeout?: number;
     maximumAge?: number;
   }): void;
 }
-/** The consent-labelled result of a capture attempt. Coordinates present only when granted. */
+/** The consent-labelled result of a capture attempt. Coordinates present only on a successful fix. */
 interface CapturedGeo {
   latitude?: string;
   longitude?: string;
   accuracyMeters?: number;
+  /** The browser PERMISSION decision only — never downgraded by a failed/timed-out fix. */
   consent: "granted" | "denied";
 }
 interface CaptureOptions {
-  /** Max time to wait for a fix before giving up (coarse fallback). Default 8000ms. */
+  /** High-accuracy (GPS) attempt budget before the network-based retry. Default 8000ms. */
   timeoutMs?: number;
+  /** Low-accuracy (network) retry budget when the first attempt gets no fix. Default 12000ms. */
+  fallbackTimeoutMs?: number;
   /** Override the geolocation source (tests). Defaults to `navigator.geolocation`. */
   geolocation?: GeolocationLike;
 }
 /**
- * Capture the browser's precise location IF the user consented. Resolves to a consent-labelled
- * result and never throws/rejects.
+ * Capture the browser's precise location. Resolves to a consent-labelled result and never
+ * throws/rejects. High-accuracy first; on a no-fix (not a denial) retries once at low accuracy.
  */
 declare function capturePreciseLocation(consented: boolean, opts?: CaptureOptions): Promise<CapturedGeo>;
 //#endregion

package/dist/index.d.mts

@@ -410,11 +410,17 @@ declare function AuthCallback({
 /**
  * @poly-x/react/geolocation — browser precise-location capture for sign-in (v6, FR-CNST/FR-LOC).
  *
- * The consent-gated bridge to `navigator.geolocation`. It NEVER rejects: a decline, a browser
- * permission denial, a missing API, or a timeout all resolve to `{ consent: "denied" }` with no
- * coordinates, so the caller can always proceed — sign-in must never block on location (D52).
- * The captured value is posted to the BFF, which forwards it to the platform on the token
- * exchange; the platform stores precise only when consent is `granted`, else coarse (IP).
+ * The consent-gated bridge to `navigator.geolocation`. It NEVER rejects: a missing API resolves
+ * to `{ consent: "denied" }` with no coordinates so the caller can always proceed — sign-in must
+ * never block on location (D52).
+ *
+ * Consent vs. fix are kept SEPARATE. `consent` reflects the browser PERMISSION decision only:
+ * `denied` means the user actually said no (`PERMISSION_DENIED`). A position that is merely
+ * unavailable or times out (common on desktops with no GPS) is NOT a denial — the user consented,
+ * we just couldn't get coordinates, so consent stays `granted` with no coords and the platform
+ * uses the coarse (IP) fallback. Conflating the two is why an allowed login could be stored as
+ * `denied` + coarse. On a no-fix (not a denial) we retry once at low accuracy (network-based),
+ * which is far more reliable than high-accuracy GPS on desktop browsers.
  */
 /** Minimal shape of the browser Geolocation API we depend on (injectable for testing). */
 interface GeolocationLike {
@@ -424,28 +430,33 @@ interface GeolocationLike {
       longitude: number;
       accuracy?: number;
     };
-  }) => void, error?: (err: unknown) => void, options?: {
+  }) => void, error?: (err: {
+    code?: number;
+  } | unknown) => void, options?: {
     enableHighAccuracy?: boolean;
     timeout?: number;
     maximumAge?: number;
   }): void;
 }
-/** The consent-labelled result of a capture attempt. Coordinates present only when granted. */
+/** The consent-labelled result of a capture attempt. Coordinates present only on a successful fix. */
 interface CapturedGeo {
   latitude?: string;
   longitude?: string;
   accuracyMeters?: number;
+  /** The browser PERMISSION decision only — never downgraded by a failed/timed-out fix. */
   consent: "granted" | "denied";
 }
 interface CaptureOptions {
-  /** Max time to wait for a fix before giving up (coarse fallback). Default 8000ms. */
+  /** High-accuracy (GPS) attempt budget before the network-based retry. Default 8000ms. */
   timeoutMs?: number;
+  /** Low-accuracy (network) retry budget when the first attempt gets no fix. Default 12000ms. */
+  fallbackTimeoutMs?: number;
   /** Override the geolocation source (tests). Defaults to `navigator.geolocation`. */
   geolocation?: GeolocationLike;
 }
 /**
- * Capture the browser's precise location IF the user consented. Resolves to a consent-labelled
- * result and never throws/rejects.
+ * Capture the browser's precise location. Resolves to a consent-labelled result and never
+ * throws/rejects. High-accuracy first; on a no-fix (not a denial) retries once at low accuracy.
  */
 declare function capturePreciseLocation(consented: boolean, opts?: CaptureOptions): Promise<CapturedGeo>;
 //#endregion

package/dist/index.mjs

@@ -514,43 +514,68 @@ function Protected({ children, fallback = null, loading = null }) {
 }
 //#endregion
 //#region src/geolocation.ts
-/**
-* Capture the browser's precise location IF the user consented. Resolves to a consent-labelled
-* result and never throws/rejects.
-*/
-async function capturePreciseLocation(consented, opts = {}) {
-	if (!consented) return { consent: "denied" };
-	const geo = opts.geolocation ?? (typeof navigator !== "undefined" ? navigator.geolocation : void 0);
-	if (!geo) return { consent: "denied" };
-	const timeoutMs = opts.timeoutMs ?? 8e3;
+/** W3C Geolocation `PositionError.PERMISSION_DENIED`. The only code that means a real "no". */
+const PERMISSION_DENIED = 1;
+/** One capture attempt at a given accuracy. Never rejects. */
+function attemptCapture(geo, highAccuracy, timeout) {
 	return new Promise((resolve) => {
 		let settled = false;
-		const done = (result) => {
+		const done = (outcome) => {
 			if (settled) return;
 			settled = true;
-			resolve(result);
+			resolve(outcome);
 		};
-		const timer = setTimeout(() => done({ consent: "denied" }), timeoutMs + 500);
-		const finish = (result) => {
+		const timer = setTimeout(() => done({
+			result: { consent: "granted" },
+			retriable: true
+		}), timeout + 1500);
+		const finish = (outcome) => {
 			clearTimeout(timer);
-			done(result);
+			done(outcome);
 		};
 		try {
 			geo.getCurrentPosition((position) => finish({
-				latitude: String(position.coords.latitude),
-				longitude: String(position.coords.longitude),
-				accuracyMeters: typeof position.coords.accuracy === "number" ? position.coords.accuracy : void 0,
-				consent: "granted"
-			}), () => finish({ consent: "denied" }), {
-				enableHighAccuracy: true,
-				timeout: timeoutMs,
+				result: {
+					latitude: String(position.coords.latitude),
+					longitude: String(position.coords.longitude),
+					accuracyMeters: typeof position.coords.accuracy === "number" ? position.coords.accuracy : void 0,
+					consent: "granted"
+				},
+				retriable: false
+			}), (err) => {
+				const code = err?.code;
+				const denied = typeof code === "number" && code === PERMISSION_DENIED;
+				finish({
+					result: { consent: denied ? "denied" : "granted" },
+					retriable: !denied
+				});
+			}, {
+				enableHighAccuracy: highAccuracy,
+				timeout,
 				maximumAge: 0
 			});
 		} catch {
-			finish({ consent: "denied" });
+			finish({
+				result: { consent: "granted" },
+				retriable: true
+			});
 		}
 	});
 }
+/**
+* Capture the browser's precise location. Resolves to a consent-labelled result and never
+* throws/rejects. High-accuracy first; on a no-fix (not a denial) retries once at low accuracy.
+*/
+async function capturePreciseLocation(consented, opts = {}) {
+	if (!consented) return { consent: "denied" };
+	const geo = opts.geolocation ?? (typeof navigator !== "undefined" ? navigator.geolocation : void 0);
+	if (!geo) return { consent: "denied" };
+	const highAccuracyMs = opts.timeoutMs ?? 8e3;
+	const lowAccuracyMs = opts.fallbackTimeoutMs ?? 12e3;
+	const first = await attemptCapture(geo, true, highAccuracyMs);
+	if (first.result.latitude !== void 0 || !first.retriable) return first.result;
+	return (await attemptCapture(geo, false, lowAccuracyMs)).result;
+}
 //#endregion
 //#region src/components/sign-in.tsx
 const DEFAULT_LABELS$3 = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poly-x/react",
-  "version": "0.1.0-alpha.16",
+  "version": "0.1.0-alpha.17",
   "description": "PolyX SDK for React SPAs - provider, hooks, drop-in auth UI",
   "license": "MIT",
   "type": "module",
@@ -27,7 +27,7 @@
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.cts",
   "dependencies": {
-    "@poly-x/core": "0.1.0-alpha.16"
+    "@poly-x/core": "0.1.0-alpha.17"
   },
   "peerDependencies": {
     "react": ">=18",