@ait-co/polyfill 0.1.5 → 0.1.6

package/dist/shims/geolocation.cjs

@@ -0,0 +1,356 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/detect.ts
+/**
+* Environment detection: are we running inside Apps in Toss, or a plain browser?
+*
+* Strategy: call the SDK's `getAppsInTossGlobals()` — a synchronous export
+* that returns the runtime's Toss globals (deploymentId, brand name, …)
+* inside the Apps in Toss runtime and throws (RN bridge unavailable)
+* anywhere else. The SDK itself is an **optional** peer dependency; if its
+* module can't be imported we are definitely not inside Toss.
+*
+* Just having the SDK module resolvable is not enough — apps can bundle it
+* and still run in a plain browser. We need the bridge probe to confirm.
+*
+* UA sniffing (spoofable) is avoided. We do call `getAppsInTossGlobals`, but
+* that's a constant read from the bridge — no permission dialogs, no
+* analytics fire. In a plain browser the bridge lookup fails fast (sync
+* throw, microsecond-scale), so the startup cost is negligible.
+*/
+let cached;
+/**
+* Returns `true` iff we detect we are running in an environment where the
+* Apps in Toss SDK (`@apps-in-toss/web-framework`) is present and usable.
+*
+* Async because we use dynamic `import()` to probe the optional peer dep
+* without forcing it into the consumer's bundle.
+*/
+async function isTossEnvironment() {
+	const force = globalThis.__AIT_POLYFILL_FORCE__;
+	if (force === "toss") return true;
+	if (force === "browser") return false;
+	if (cached !== void 0) return cached;
+	const mod = await loadTossSdk();
+	if (typeof mod?.getAppsInTossGlobals !== "function") {
+		cached = false;
+		return cached;
+	}
+	try {
+		const globals = mod.getAppsInTossGlobals();
+		cached = Boolean(globals) && typeof globals === "object";
+	} catch {
+		cached = false;
+	}
+	return cached;
+}
+/**
+* Lazy SDK accessor — returns the module if available, else `null`. Callers
+* are expected to `await` and null-check. Never throws.
+*/
+async function loadTossSdk() {
+	try {
+		return await import("@apps-in-toss/web-framework");
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/shims/_install-helpers.ts
+/**
+* Mutate methods on an existing object rather than replacing the object
+* itself. This is the path we take for `navigator.geolocation`, `navigator.share`,
+* and `navigator.vibrate` in Chromium, where the slot on `navigator` is a
+* non-configurable own property that we cannot replace — but the methods
+* themselves (or the methods on the referenced object) are still
+* `configurable: true, writable: true`.
+*
+* Each replacement is installed via plain assignment. If any slot is not
+* writable (e.g. frozen object), install is aborted and previously-applied
+* replacements are rolled back, so the caller observes an atomic "all or
+* nothing" failure as `null`. The caller is expected to degrade gracefully
+* (e.g. log a one-time `console.warn`) when that happens.
+*/
+function installObjectMethods(target, replacements) {
+	const methods = {};
+	const applied = [];
+	const bag = target;
+	for (const key of Object.keys(replacements)) {
+		const hadOwn = Object.hasOwn(target, key);
+		const original = bag[key];
+		try {
+			bag[key] = replacements[key];
+		} catch {
+			for (const applieKey of applied) {
+				const prev = methods[applieKey];
+				if (!prev) continue;
+				if (prev.hadOwn) bag[applieKey] = prev.original;
+				else delete bag[applieKey];
+			}
+			return null;
+		}
+		if (bag[key] !== replacements[key]) {
+			for (const applieKey of applied) {
+				const prev = methods[applieKey];
+				if (!prev) continue;
+				if (prev.hadOwn) bag[applieKey] = prev.original;
+				else delete bag[applieKey];
+			}
+			return null;
+		}
+		methods[key] = {
+			hadOwn,
+			original
+		};
+		applied.push(key);
+	}
+	return {
+		target,
+		methods
+	};
+}
+/**
+* Reverse an `installObjectMethods` snapshot. Reassigns originals for slots
+* that were own properties before install; deletes the override for slots
+* that were inherited (so the prototype method surfaces again).
+*/
+function restoreObjectMethods(snapshot) {
+	const bag = snapshot.target;
+	for (const key of Object.keys(snapshot.methods)) {
+		const entry = snapshot.methods[key];
+		if (!entry) continue;
+		try {
+			if (entry.hadOwn) bag[key] = entry.original;
+			else delete bag[key];
+		} catch {}
+	}
+}
+//#endregion
+//#region src/shims/geolocation.ts
+/**
+* `navigator.geolocation` shim.
+*
+* Inside Apps in Toss → routes through the SDK:
+*   - `getCurrentPosition` → `getCurrentLocation({ accuracy })`
+*   - `watchPosition` / `clearWatch` → `startUpdateLocation({ onEvent, onError, options })`
+*
+* Outside Apps in Toss → defers to the browser's native `navigator.geolocation`.
+* If neither is available, the error callback receives a `GeolocationPositionError`.
+*
+* Install strategy: **method-level**. We do **not** replace `navigator.geolocation`
+* itself — Chromium marks that slot as a non-configurable own property, which
+* both `defineProperty(navigator, 'geolocation', …)` and the prototype-level
+* fallback cannot override (the instance shadow blocks prototype reads). We
+* instead mutate the methods on the existing `Geolocation` object, whose own
+* method descriptors are configurable+writable in every browser we've seen.
+*
+* SDK/Web shape mismatch handled here:
+*   - SDK `Accuracy` is a numeric enum (1 = Lowest … 6 = BestForNavigation); the
+*     standard `PositionOptions.enableHighAccuracy` is a boolean. We map
+*     `true → Accuracy.High (4, "~10m")` and `false → Accuracy.Balanced (3)`.
+*     `Highest (5)` / `BestForNavigation (6)` are available but carry a battery
+*     cost that's rarely what mini-apps want; consumers who need them should
+*     call the SDK directly.
+*   - SDK coords lack `speed`; we surface `null` (per the W3C spec when unknown).
+*   - SDK `startUpdateLocation` returns an `unsubscribe` fn; we wrap it behind
+*     a numeric watch id so `clearWatch(id)` behaves like the standard.
+*
+* Caveat: watch ids reset whenever the shim is uninstalled and reinstalled;
+* they are not stable across such cycles. Ids obtained before uninstall
+* cannot be cleared after uninstall — `clearWatch(id)` on the restored native
+* `navigator.geolocation` uses a different id space, so the SDK subscription
+* leaks. Consumers should `clearWatch` all outstanding ids before calling
+* `uninstall()`.
+*/
+const BACKUP_KEY = Symbol.for("@ait-co/polyfill/geolocation.original");
+const SNAPSHOT_KEY = Symbol.for("@ait-co/polyfill/geolocation.snapshot");
+const ACCURACY_BALANCED = 3;
+const ACCURACY_HIGH = 4;
+function toStandardPosition(sdk) {
+	const coordsData = {
+		latitude: sdk.coords.latitude,
+		longitude: sdk.coords.longitude,
+		altitude: sdk.coords.altitude,
+		accuracy: sdk.coords.accuracy,
+		altitudeAccuracy: sdk.coords.altitudeAccuracy,
+		heading: sdk.coords.heading,
+		speed: null
+	};
+	return {
+		coords: {
+			...coordsData,
+			toJSON() {
+				return { ...coordsData };
+			}
+		},
+		timestamp: sdk.timestamp,
+		toJSON() {
+			return {
+				coords: { ...coordsData },
+				timestamp: sdk.timestamp
+			};
+		}
+	};
+}
+function toPositionError(code, message) {
+	const Ctor = globalThis.GeolocationPositionError;
+	if (typeof Ctor === "function") {
+		const proto = Ctor.prototype;
+		if (proto) {
+			const shape = {
+				code,
+				message
+			};
+			Object.setPrototypeOf(shape, proto);
+			return shape;
+		}
+	}
+	return {
+		code,
+		message,
+		PERMISSION_DENIED: 1,
+		POSITION_UNAVAILABLE: 2,
+		TIMEOUT: 3
+	};
+}
+function accuracyFromOptions(options) {
+	return options?.enableHighAccuracy ? ACCURACY_HIGH : ACCURACY_BALANCED;
+}
+function createGeolocationShim(fallback) {
+	let nextWatchId = 1;
+	const sdkWatches = /* @__PURE__ */ new Map();
+	const nativeWatches = /* @__PURE__ */ new Map();
+	const pendingWatches = /* @__PURE__ */ new Map();
+	return {
+		getCurrentPosition(success, error, options) {
+			(async () => {
+				if (await isTossEnvironment()) {
+					const fn = (await loadTossSdk())?.getCurrentLocation;
+					if (typeof fn === "function") {
+						try {
+							success(toStandardPosition(await fn({ accuracy: accuracyFromOptions(options) })));
+						} catch (e) {
+							error?.(toPositionError(2, e instanceof Error ? e.message : "[@ait-co/polyfill] getCurrentLocation failed."));
+						}
+						return;
+					}
+				}
+				if (!fallback.getCurrentPosition) {
+					error?.(toPositionError(2, "[@ait-co/polyfill] navigator.geolocation is not available in this environment."));
+					return;
+				}
+				fallback.getCurrentPosition(success, error, options);
+			})();
+		},
+		watchPosition(success, error, options) {
+			const id = nextWatchId++;
+			const pending = { cancelled: false };
+			pendingWatches.set(id, pending);
+			(async () => {
+				if (await isTossEnvironment()) {
+					const fn = (await loadTossSdk())?.startUpdateLocation;
+					if (typeof fn === "function") {
+						if (pending.cancelled) {
+							pendingWatches.delete(id);
+							return;
+						}
+						const unsubscribe = fn({
+							onEvent: (loc) => success(toStandardPosition(loc)),
+							onError: (err) => error?.(toPositionError(2, err instanceof Error ? err.message : "[@ait-co/polyfill] startUpdateLocation failed.")),
+							options: {
+								accuracy: accuracyFromOptions(options),
+								timeInterval: 1e3,
+								distanceInterval: 0
+							}
+						});
+						if (pending.cancelled) {
+							unsubscribe();
+							pendingWatches.delete(id);
+							return;
+						}
+						sdkWatches.set(id, unsubscribe);
+						pendingWatches.delete(id);
+						return;
+					}
+				}
+				if (!fallback.watchPosition) {
+					pendingWatches.delete(id);
+					error?.(toPositionError(2, "[@ait-co/polyfill] navigator.geolocation is not available in this environment."));
+					return;
+				}
+				if (pending.cancelled) {
+					pendingWatches.delete(id);
+					return;
+				}
+				const nativeId = fallback.watchPosition(success, error, options);
+				if (pending.cancelled) {
+					fallback.clearWatch?.(nativeId);
+					pendingWatches.delete(id);
+					return;
+				}
+				nativeWatches.set(id, nativeId);
+				pendingWatches.delete(id);
+			})();
+			return id;
+		},
+		clearWatch(id) {
+			const pending = pendingWatches.get(id);
+			if (pending) {
+				pending.cancelled = true;
+				pendingWatches.delete(id);
+				return;
+			}
+			const unsubscribe = sdkWatches.get(id);
+			if (unsubscribe) {
+				unsubscribe();
+				sdkWatches.delete(id);
+				return;
+			}
+			const nativeId = nativeWatches.get(id);
+			if (nativeId !== void 0 && fallback.clearWatch) {
+				fallback.clearWatch(nativeId);
+				nativeWatches.delete(id);
+			}
+		}
+	};
+}
+function installGeolocationShim() {
+	if (typeof navigator === "undefined") return () => {};
+	const host = navigator;
+	if (BACKUP_KEY in host) return () => uninstallGeolocationShim();
+	const target = navigator.geolocation;
+	if (!target) {
+		host[BACKUP_KEY] = void 0;
+		return () => uninstallGeolocationShim();
+	}
+	const shim = createGeolocationShim({
+		getCurrentPosition: target.getCurrentPosition?.bind(target),
+		watchPosition: target.watchPosition?.bind(target),
+		clearWatch: target.clearWatch?.bind(target)
+	});
+	const snapshot = installObjectMethods(target, {
+		getCurrentPosition: shim.getCurrentPosition,
+		watchPosition: shim.watchPosition,
+		clearWatch: shim.clearWatch
+	});
+	if (!snapshot) {
+		host[BACKUP_KEY] = void 0;
+		return () => uninstallGeolocationShim();
+	}
+	host[BACKUP_KEY] = { target };
+	host[SNAPSHOT_KEY] = snapshot;
+	return uninstallGeolocationShim;
+}
+function uninstallGeolocationShim() {
+	if (typeof navigator === "undefined") return;
+	const host = navigator;
+	if (!(BACKUP_KEY in host)) return;
+	const snapshot = host[SNAPSHOT_KEY];
+	if (snapshot) restoreObjectMethods(snapshot);
+	delete host[BACKUP_KEY];
+	delete host[SNAPSHOT_KEY];
+}
+//#endregion
+exports.installGeolocationShim = installGeolocationShim;
+exports.uninstallGeolocationShim = uninstallGeolocationShim;
+
+//# sourceMappingURL=geolocation.cjs.map

package/dist/shims/geolocation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"geolocation.cjs","names":[],"sources":["../../src/detect.ts","../../src/shims/_install-helpers.ts","../../src/shims/geolocation.ts"],"sourcesContent":["/**\n * Environment detection: are we running inside Apps in Toss, or a plain browser?\n *\n * Strategy: call the SDK's `getAppsInTossGlobals()` — a synchronous export\n * that returns the runtime's Toss globals (deploymentId, brand name, …)\n * inside the Apps in Toss runtime and throws (RN bridge unavailable)\n * anywhere else. The SDK itself is an **optional** peer dependency; if its\n * module can't be imported we are definitely not inside Toss.\n *\n * Just having the SDK module resolvable is not enough — apps can bundle it\n * and still run in a plain browser. We need the bridge probe to confirm.\n *\n * UA sniffing (spoofable) is avoided. We do call `getAppsInTossGlobals`, but\n * that's a constant read from the bridge — no permission dialogs, no\n * analytics fire. In a plain browser the bridge lookup fails fast (sync\n * throw, microsecond-scale), so the startup cost is negligible.\n */\n\nlet cached: boolean | undefined;\n\n/**\n * Reset the cached detection result. Primarily for tests.\n */\nexport function resetDetection(): void {\n  cached = undefined;\n}\n\n/**\n * Synchronous read of the cached detection result. Returns:\n *   - `true` / `false` if an override is active or the async detection has\n *     already resolved\n *   - `undefined` if detection hasn't run yet\n *\n * Used by spec-sync APIs (e.g. `navigator.canShare`) that can't `await`\n * detection.\n */\nexport function isTossEnvironmentCached(): boolean | undefined {\n  const force = globalThis.__AIT_POLYFILL_FORCE__;\n  if (force === 'toss') return true;\n  if (force === 'browser') return false;\n  return cached;\n}\n\n/**\n * Returns `true` iff we detect we are running in an environment where the\n * Apps in Toss SDK (`@apps-in-toss/web-framework`) is present and usable.\n *\n * Async because we use dynamic `import()` to probe the optional peer dep\n * without forcing it into the consumer's bundle.\n */\nexport async function isTossEnvironment(): Promise<boolean> {\n  // Override check precedes cache so `devtools` / tests can flip the result\n  // mid-session without a `resetDetection()` call.\n  const force = globalThis.__AIT_POLYFILL_FORCE__;\n  if (force === 'toss') return true;\n  if (force === 'browser') return false;\n\n  if (cached !== undefined) return cached;\n\n  const mod = await loadTossSdk();\n  if (typeof mod?.getAppsInTossGlobals !== 'function') {\n    cached = false;\n    return cached;\n  }\n  // Inside Toss the bridge returns a populated globals object. In a plain\n  // browser the RN bridge isn't attached and the call throws — that's our\n  // signal. Any non-throwing call with an object return is treated as Toss.\n  try {\n    const globals = mod.getAppsInTossGlobals();\n    cached = Boolean(globals) && typeof globals === 'object';\n  } catch {\n    cached = false;\n  }\n  return cached;\n}\n\n/**\n * Lazy SDK accessor — returns the module if available, else `null`. Callers\n * are expected to `await` and null-check. Never throws.\n */\nexport async function loadTossSdk(): Promise<typeof import('@apps-in-toss/web-framework') | null> {\n  try {\n    return await import('@apps-in-toss/web-framework');\n  } catch {\n    return null;\n  }\n}\n","/**\n * Shared helpers for installing shims on `navigator`.\n *\n * Chromium now marks a handful of `navigator` properties (e.g. `geolocation`,\n * `clipboard`) as non-configurable **own** properties on the instance. That\n * means a plain `Object.defineProperty(navigator, 'x', …)` throws\n * `TypeError: Cannot redefine property`.\n *\n * The workaround is to shim at the prototype level — `Navigator.prototype`\n * keeps these as configurable accessors, so we can swap them there and every\n * instance that falls through to the prototype (including `window.navigator`)\n * sees the shim. We only reach for the prototype when the instance-level\n * assignment refuses.\n *\n * For restoration we remember the descriptor chain (instance + prototype) so\n * `uninstall()` puts the browser back in its original state.\n */\n\ntype PropertyLocation = 'instance' | 'prototype';\n\nexport interface InstallSnapshot {\n  /** Where we ended up writing the shim. */\n  location: PropertyLocation;\n  /** Original descriptor at that location (may be undefined if nothing was there). */\n  originalDescriptor: PropertyDescriptor | undefined;\n  /** `true` iff the original property lived on the instance before we touched it. */\n  instanceHadOwn: boolean;\n}\n\n/**\n * Install `descriptor` at `navigator[prop]`. Prefer instance-level; if the\n * browser refuses (property is non-configurable on the instance), install on\n * `Navigator.prototype` instead.\n *\n * Returns a snapshot describing where the original value was, which\n * `restoreNavigatorProperty` uses to undo the install.\n */\nexport function installNavigatorProperty(\n  prop: string,\n  descriptor: PropertyDescriptor,\n): InstallSnapshot {\n  const nav = navigator as unknown as Record<PropertyKey, unknown>;\n  const instanceDesc = Object.getOwnPropertyDescriptor(nav, prop);\n  const instanceHadOwn = instanceDesc !== undefined;\n\n  // Fast path: instance-level property is missing or configurable.\n  if (!instanceDesc || instanceDesc.configurable) {\n    try {\n      Object.defineProperty(nav, prop, descriptor);\n      return { location: 'instance', originalDescriptor: instanceDesc, instanceHadOwn };\n    } catch {\n      // Fall through to prototype-level install.\n    }\n  }\n\n  // Prototype-level install. Drop the instance-level shadow so the prototype\n  // accessor is visible to readers on `navigator`.\n  const proto = Object.getPrototypeOf(nav) as object;\n  const protoDesc = Object.getOwnPropertyDescriptor(proto, prop);\n\n  if (instanceHadOwn) {\n    // Try to remove the instance-level shadow. On non-configurable it throws —\n    // we deliberately ignore that; prototype-level install still wins because\n    // the prototype accessor shows through when we read via `navigator[prop]`.\n    try {\n      delete nav[prop];\n    } catch {\n      /* non-configurable own — leave it; prototype install still useful */\n    }\n  }\n\n  Object.defineProperty(proto, prop, descriptor);\n  return { location: 'prototype', originalDescriptor: protoDesc, instanceHadOwn };\n}\n\n/**\n * Reverse the install recorded in `snapshot`. If the original descriptor was\n * `undefined` (property didn't exist before), delete the property instead of\n * re-defining it.\n */\nexport function restoreNavigatorProperty(prop: string, snapshot: InstallSnapshot): void {\n  const target =\n    snapshot.location === 'instance'\n      ? (navigator as unknown as Record<PropertyKey, unknown>)\n      : (Object.getPrototypeOf(navigator) as object);\n\n  if (snapshot.originalDescriptor) {\n    try {\n      Object.defineProperty(target, prop, snapshot.originalDescriptor);\n    } catch {\n      /* descriptor was non-configurable upstream; we can't undo — rare. */\n    }\n  } else {\n    try {\n      delete (target as Record<PropertyKey, unknown>)[prop];\n    } catch {\n      /* non-configurable — rare. */\n    }\n  }\n\n  // If our install pushed past an instance shadow, we leave the instance alone\n  // — the descriptor we captured for `instanceHadOwn: true` lives on the\n  // instance and was not modified at install time.\n}\n\n/**\n * Method-level install snapshot. Captured per-key so `restoreObjectMethods`\n * can distinguish \"was an own property, reassign it\" from \"was inherited,\n * delete the override so the prototype method surfaces again\".\n */\nexport interface MethodInstallSnapshot {\n  target: object;\n  methods: Record<string, { hadOwn: boolean; original: unknown }>;\n}\n\n/**\n * Mutate methods on an existing object rather than replacing the object\n * itself. This is the path we take for `navigator.geolocation`, `navigator.share`,\n * and `navigator.vibrate` in Chromium, where the slot on `navigator` is a\n * non-configurable own property that we cannot replace — but the methods\n * themselves (or the methods on the referenced object) are still\n * `configurable: true, writable: true`.\n *\n * Each replacement is installed via plain assignment. If any slot is not\n * writable (e.g. frozen object), install is aborted and previously-applied\n * replacements are rolled back, so the caller observes an atomic \"all or\n * nothing\" failure as `null`. The caller is expected to degrade gracefully\n * (e.g. log a one-time `console.warn`) when that happens.\n */\nexport function installObjectMethods(\n  target: object,\n  replacements: Record<string, (...args: never[]) => unknown>,\n): MethodInstallSnapshot | null {\n  const methods: Record<string, { hadOwn: boolean; original: unknown }> = {};\n  const applied: string[] = [];\n  const bag = target as Record<string, unknown>;\n\n  for (const key of Object.keys(replacements)) {\n    const hadOwn = Object.hasOwn(target, key);\n    const original = bag[key];\n    try {\n      bag[key] = replacements[key] as unknown;\n    } catch {\n      // Non-writable / frozen. Roll back and return null.\n      for (const applieKey of applied) {\n        const prev = methods[applieKey];\n        if (!prev) continue;\n        if (prev.hadOwn) {\n          bag[applieKey] = prev.original;\n        } else {\n          delete bag[applieKey];\n        }\n      }\n      return null;\n    }\n    // Verify the assignment actually stuck — silent-failure descriptors (e.g.\n    // `writable: false` without strict mode) can skip the throw and leave the\n    // original value in place. Treat that the same as a throw.\n    if (bag[key] !== (replacements[key] as unknown)) {\n      for (const applieKey of applied) {\n        const prev = methods[applieKey];\n        if (!prev) continue;\n        if (prev.hadOwn) {\n          bag[applieKey] = prev.original;\n        } else {\n          delete bag[applieKey];\n        }\n      }\n      return null;\n    }\n    methods[key] = { hadOwn, original };\n    applied.push(key);\n  }\n\n  return { target, methods };\n}\n\n/**\n * Reverse an `installObjectMethods` snapshot. Reassigns originals for slots\n * that were own properties before install; deletes the override for slots\n * that were inherited (so the prototype method surfaces again).\n */\nexport function restoreObjectMethods(snapshot: MethodInstallSnapshot): void {\n  const bag = snapshot.target as Record<string, unknown>;\n  for (const key of Object.keys(snapshot.methods)) {\n    const entry = snapshot.methods[key];\n    if (!entry) continue;\n    try {\n      if (entry.hadOwn) {\n        bag[key] = entry.original;\n      } else {\n        delete bag[key];\n      }\n    } catch {\n      /* frozen between install and restore — rare. */\n    }\n  }\n}\n","/**\n * `navigator.geolocation` shim.\n *\n * Inside Apps in Toss → routes through the SDK:\n *   - `getCurrentPosition` → `getCurrentLocation({ accuracy })`\n *   - `watchPosition` / `clearWatch` → `startUpdateLocation({ onEvent, onError, options })`\n *\n * Outside Apps in Toss → defers to the browser's native `navigator.geolocation`.\n * If neither is available, the error callback receives a `GeolocationPositionError`.\n *\n * Install strategy: **method-level**. We do **not** replace `navigator.geolocation`\n * itself — Chromium marks that slot as a non-configurable own property, which\n * both `defineProperty(navigator, 'geolocation', …)` and the prototype-level\n * fallback cannot override (the instance shadow blocks prototype reads). We\n * instead mutate the methods on the existing `Geolocation` object, whose own\n * method descriptors are configurable+writable in every browser we've seen.\n *\n * SDK/Web shape mismatch handled here:\n *   - SDK `Accuracy` is a numeric enum (1 = Lowest … 6 = BestForNavigation); the\n *     standard `PositionOptions.enableHighAccuracy` is a boolean. We map\n *     `true → Accuracy.High (4, \"~10m\")` and `false → Accuracy.Balanced (3)`.\n *     `Highest (5)` / `BestForNavigation (6)` are available but carry a battery\n *     cost that's rarely what mini-apps want; consumers who need them should\n *     call the SDK directly.\n *   - SDK coords lack `speed`; we surface `null` (per the W3C spec when unknown).\n *   - SDK `startUpdateLocation` returns an `unsubscribe` fn; we wrap it behind\n *     a numeric watch id so `clearWatch(id)` behaves like the standard.\n *\n * Caveat: watch ids reset whenever the shim is uninstalled and reinstalled;\n * they are not stable across such cycles. Ids obtained before uninstall\n * cannot be cleared after uninstall — `clearWatch(id)` on the restored native\n * `navigator.geolocation` uses a different id space, so the SDK subscription\n * leaks. Consumers should `clearWatch` all outstanding ids before calling\n * `uninstall()`.\n */\n\nimport { isTossEnvironment, loadTossSdk } from '../detect.js';\nimport {\n  installObjectMethods,\n  type MethodInstallSnapshot,\n  restoreObjectMethods,\n} from './_install-helpers.js';\n\nconst BACKUP_KEY = Symbol.for('@ait-co/polyfill/geolocation.original');\nconst SNAPSHOT_KEY = Symbol.for('@ait-co/polyfill/geolocation.snapshot');\n\ninterface BackupHost {\n  [BACKUP_KEY]?: { target: Geolocation } | undefined;\n  [SNAPSHOT_KEY]?: MethodInstallSnapshot | undefined;\n}\n\n// SDK Accuracy enum values. We don't import the enum at runtime (peer is\n// optional), so we hard-code the numeric constants used by the SDK. Stable\n// ABI per the SDK's exported numeric enum.\nconst ACCURACY_BALANCED = 3;\nconst ACCURACY_HIGH = 4;\n\ninterface SdkLocationCoords {\n  latitude: number;\n  longitude: number;\n  altitude: number;\n  accuracy: number;\n  altitudeAccuracy: number;\n  heading: number;\n}\n\ninterface SdkLocation {\n  timestamp: number;\n  coords: SdkLocationCoords;\n}\n\nfunction toStandardPosition(sdk: SdkLocation): GeolocationPosition {\n  const coordsData = {\n    latitude: sdk.coords.latitude,\n    longitude: sdk.coords.longitude,\n    altitude: sdk.coords.altitude,\n    accuracy: sdk.coords.accuracy,\n    altitudeAccuracy: sdk.coords.altitudeAccuracy,\n    heading: sdk.coords.heading,\n    // SDK does not surface speed. Per spec, null means \"unknown\".\n    speed: null,\n  };\n  const coords: GeolocationCoordinates = {\n    ...coordsData,\n    toJSON() {\n      return { ...coordsData };\n    },\n  };\n  return {\n    coords,\n    timestamp: sdk.timestamp,\n    toJSON() {\n      return { coords: { ...coordsData }, timestamp: sdk.timestamp };\n    },\n  };\n}\n\nfunction toPositionError(code: 1 | 2 | 3, message: string): GeolocationPositionError {\n  // Prefer the real constructor when available (every real browser ships it).\n  // The spec says GeolocationPositionError is not constructable, so we fall\n  // through to a fabricated object whose prototype is patched via\n  // `setPrototypeOf` — that keeps `instanceof` checks in consumer code working\n  // and picks up the spec's PERMISSION_DENIED / POSITION_UNAVAILABLE / TIMEOUT\n  // constants from the real prototype rather than hard-coding them (avoids\n  // drift if the spec ever grows a new code).\n  const Ctor = (globalThis as { GeolocationPositionError?: unknown }).GeolocationPositionError;\n  if (typeof Ctor === 'function') {\n    const proto = (Ctor as { prototype?: object }).prototype;\n    if (proto) {\n      const shape: { code: number; message: string } = { code, message };\n      Object.setPrototypeOf(shape, proto);\n      return shape as GeolocationPositionError;\n    }\n  }\n  // jsdom / last-resort fallback: fabricate the spec shape with hard-coded\n  // constants since there's no prototype to delegate to.\n  return {\n    code,\n    message,\n    PERMISSION_DENIED: 1,\n    POSITION_UNAVAILABLE: 2,\n    TIMEOUT: 3,\n  } as GeolocationPositionError;\n}\n\nfunction accuracyFromOptions(options: PositionOptions | undefined): number {\n  return options?.enableHighAccuracy ? ACCURACY_HIGH : ACCURACY_BALANCED;\n}\n\n/**\n * Minimal view of the native `Geolocation` methods we forward to. We pass\n * the **captured originals** here, not a reference to `navigator.geolocation`\n * itself — after install the methods on that object ARE the shim, so using\n * `navigator.geolocation.getCurrentPosition(…)` as a fallback would infinite-loop.\n */\ninterface GeolocationFallback {\n  getCurrentPosition: Geolocation['getCurrentPosition'] | undefined;\n  watchPosition: Geolocation['watchPosition'] | undefined;\n  clearWatch: Geolocation['clearWatch'] | undefined;\n}\n\ninterface GeolocationShim {\n  getCurrentPosition: Geolocation['getCurrentPosition'];\n  watchPosition: Geolocation['watchPosition'];\n  clearWatch: Geolocation['clearWatch'];\n}\n\nfunction createGeolocationShim(fallback: GeolocationFallback): GeolocationShim {\n  // Numeric watch id → SDK unsubscribe fn. Keeps the shim's API in line with\n  // the standard even though the SDK issues unsubscribe closures instead.\n  // `pendingWatches` closes the race where `clearWatch` is called before the\n  // async `watchPosition` installer resolves — without it we'd leak the SDK\n  // subscription.\n  let nextWatchId = 1;\n  const sdkWatches = new Map<number, () => void>();\n  const nativeWatches = new Map<number, number>();\n  const pendingWatches = new Map<number, { cancelled: boolean }>();\n\n  const shim: GeolocationShim = {\n    getCurrentPosition(success, error, options) {\n      void (async () => {\n        if (await isTossEnvironment()) {\n          const sdk = await loadTossSdk();\n          const fn = (sdk as { getCurrentLocation?: unknown } | null)?.getCurrentLocation;\n          if (typeof fn === 'function') {\n            try {\n              const loc = (await (fn as (o: { accuracy: number }) => Promise<SdkLocation>)({\n                accuracy: accuracyFromOptions(options),\n              })) as SdkLocation;\n              success(toStandardPosition(loc));\n            } catch (e) {\n              error?.(\n                toPositionError(\n                  2,\n                  e instanceof Error ? e.message : '[@ait-co/polyfill] getCurrentLocation failed.',\n                ),\n              );\n            }\n            return;\n          }\n        }\n        if (!fallback.getCurrentPosition) {\n          error?.(\n            toPositionError(\n              2,\n              '[@ait-co/polyfill] navigator.geolocation is not available in this environment.',\n            ),\n          );\n          return;\n        }\n        fallback.getCurrentPosition(success, error, options);\n      })();\n    },\n\n    watchPosition(success, error, options) {\n      const id = nextWatchId++;\n      const pending = { cancelled: false };\n      pendingWatches.set(id, pending);\n\n      void (async () => {\n        if (await isTossEnvironment()) {\n          const sdk = await loadTossSdk();\n          const fn = (sdk as { startUpdateLocation?: unknown } | null)?.startUpdateLocation;\n          if (typeof fn === 'function') {\n            if (pending.cancelled) {\n              pendingWatches.delete(id);\n              return;\n            }\n            const unsubscribe = (\n              fn as (p: {\n                onEvent: (loc: SdkLocation) => void;\n                onError: (err: unknown) => void;\n                options: { accuracy: number; timeInterval: number; distanceInterval: number };\n              }) => () => void\n            )({\n              onEvent: (loc) => success(toStandardPosition(loc)),\n              onError: (err) =>\n                error?.(\n                  toPositionError(\n                    2,\n                    err instanceof Error\n                      ? err.message\n                      : '[@ait-co/polyfill] startUpdateLocation failed.',\n                  ),\n                ),\n              options: {\n                accuracy: accuracyFromOptions(options),\n                // Sensible defaults — web `watchPosition` has no analogues.\n                // Consumers needing sub-second updates should use the SDK directly.\n                timeInterval: 1000,\n                distanceInterval: 0,\n              },\n            });\n            if (pending.cancelled) {\n              unsubscribe();\n              pendingWatches.delete(id);\n              return;\n            }\n            sdkWatches.set(id, unsubscribe);\n            pendingWatches.delete(id);\n            return;\n          }\n        }\n        if (!fallback.watchPosition) {\n          pendingWatches.delete(id);\n          error?.(\n            toPositionError(\n              2,\n              '[@ait-co/polyfill] navigator.geolocation is not available in this environment.',\n            ),\n          );\n          return;\n        }\n        if (pending.cancelled) {\n          pendingWatches.delete(id);\n          return;\n        }\n        const nativeId = fallback.watchPosition(success, error, options);\n        if (pending.cancelled) {\n          fallback.clearWatch?.(nativeId);\n          pendingWatches.delete(id);\n          return;\n        }\n        nativeWatches.set(id, nativeId);\n        pendingWatches.delete(id);\n      })();\n\n      return id;\n    },\n\n    clearWatch(id) {\n      const pending = pendingWatches.get(id);\n      if (pending) {\n        pending.cancelled = true;\n        pendingWatches.delete(id);\n        return;\n      }\n      const unsubscribe = sdkWatches.get(id);\n      if (unsubscribe) {\n        unsubscribe();\n        sdkWatches.delete(id);\n        return;\n      }\n      const nativeId = nativeWatches.get(id);\n      if (nativeId !== undefined && fallback.clearWatch) {\n        fallback.clearWatch(nativeId);\n        nativeWatches.delete(id);\n      }\n    },\n  };\n\n  return shim;\n}\n\nexport function installGeolocationShim(): () => void {\n  if (typeof navigator === 'undefined') {\n    return () => {};\n  }\n\n  const host = navigator as unknown as BackupHost;\n  if (BACKUP_KEY in host) {\n    return () => uninstallGeolocationShim();\n  }\n\n  const target = navigator.geolocation as Geolocation | undefined;\n  if (!target) {\n    // No `navigator.geolocation` at all (rare — jsdom may expose it, real\n    // browsers always do). Nothing for the shim to mutate; bail quietly.\n    host[BACKUP_KEY] = undefined;\n    return () => uninstallGeolocationShim();\n  }\n\n  // Capture the native methods BEFORE we patch so the shim's fallback path\n  // doesn't recurse through itself.\n  const fallback: GeolocationFallback = {\n    getCurrentPosition: target.getCurrentPosition?.bind(target),\n    watchPosition: target.watchPosition?.bind(target),\n    clearWatch: target.clearWatch?.bind(target),\n  };\n\n  const shim = createGeolocationShim(fallback);\n\n  const snapshot = installObjectMethods(target, {\n    getCurrentPosition: shim.getCurrentPosition as (...args: never[]) => unknown,\n    watchPosition: shim.watchPosition as (...args: never[]) => unknown,\n    clearWatch: shim.clearWatch as (...args: never[]) => unknown,\n  });\n\n  if (!snapshot) {\n    // Method slots frozen — can't install. No-op uninstall.\n    host[BACKUP_KEY] = undefined;\n    return () => uninstallGeolocationShim();\n  }\n\n  host[BACKUP_KEY] = { target };\n  host[SNAPSHOT_KEY] = snapshot;\n\n  return uninstallGeolocationShim;\n}\n\nexport function uninstallGeolocationShim(): void {\n  if (typeof navigator === 'undefined') return;\n  const host = navigator as unknown as BackupHost;\n  if (!(BACKUP_KEY in host)) return;\n\n  const snapshot = host[SNAPSHOT_KEY];\n  if (snapshot) restoreObjectMethods(snapshot);\n  delete host[BACKUP_KEY];\n  delete host[SNAPSHOT_KEY];\n}\n"],"mappings":"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"}

package/dist/shims/geolocation.d.cts

@@ -0,0 +1,41 @@
+//#region src/shims/geolocation.d.ts
+/**
+ * `navigator.geolocation` shim.
+ *
+ * Inside Apps in Toss → routes through the SDK:
+ *   - `getCurrentPosition` → `getCurrentLocation({ accuracy })`
+ *   - `watchPosition` / `clearWatch` → `startUpdateLocation({ onEvent, onError, options })`
+ *
+ * Outside Apps in Toss → defers to the browser's native `navigator.geolocation`.
+ * If neither is available, the error callback receives a `GeolocationPositionError`.
+ *
+ * Install strategy: **method-level**. We do **not** replace `navigator.geolocation`
+ * itself — Chromium marks that slot as a non-configurable own property, which
+ * both `defineProperty(navigator, 'geolocation', …)` and the prototype-level
+ * fallback cannot override (the instance shadow blocks prototype reads). We
+ * instead mutate the methods on the existing `Geolocation` object, whose own
+ * method descriptors are configurable+writable in every browser we've seen.
+ *
+ * SDK/Web shape mismatch handled here:
+ *   - SDK `Accuracy` is a numeric enum (1 = Lowest … 6 = BestForNavigation); the
+ *     standard `PositionOptions.enableHighAccuracy` is a boolean. We map
+ *     `true → Accuracy.High (4, "~10m")` and `false → Accuracy.Balanced (3)`.
+ *     `Highest (5)` / `BestForNavigation (6)` are available but carry a battery
+ *     cost that's rarely what mini-apps want; consumers who need them should
+ *     call the SDK directly.
+ *   - SDK coords lack `speed`; we surface `null` (per the W3C spec when unknown).
+ *   - SDK `startUpdateLocation` returns an `unsubscribe` fn; we wrap it behind
+ *     a numeric watch id so `clearWatch(id)` behaves like the standard.
+ *
+ * Caveat: watch ids reset whenever the shim is uninstalled and reinstalled;
+ * they are not stable across such cycles. Ids obtained before uninstall
+ * cannot be cleared after uninstall — `clearWatch(id)` on the restored native
+ * `navigator.geolocation` uses a different id space, so the SDK subscription
+ * leaks. Consumers should `clearWatch` all outstanding ids before calling
+ * `uninstall()`.
+ */
+declare function installGeolocationShim(): () => void;
+declare function uninstallGeolocationShim(): void;
+//#endregion
+export { installGeolocationShim, uninstallGeolocationShim };
+//# sourceMappingURL=geolocation.d.cts.map

package/dist/shims/geolocation.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geolocation.d.cts","names":[],"sources":["../../src/shims/geolocation.ts"],"mappings":";;AAsSA;;;;;AA8CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA9CgB,sBAAA,CAAA;AAAA,iBA8CA,wBAAA,CAAA"}