@ait-co/polyfill 0.1.5 → 0.1.6

package/dist/detect.cjs

@@ -0,0 +1,84 @@
+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;
+/**
+* Reset the cached detection result. Primarily for tests.
+*/
+function resetDetection() {
+	cached = void 0;
+}
+/**
+* Synchronous read of the cached detection result. Returns:
+*   - `true` / `false` if an override is active or the async detection has
+*     already resolved
+*   - `undefined` if detection hasn't run yet
+*
+* Used by spec-sync APIs (e.g. `navigator.canShare`) that can't `await`
+* detection.
+*/
+function isTossEnvironmentCached() {
+	const force = globalThis.__AIT_POLYFILL_FORCE__;
+	if (force === "toss") return true;
+	if (force === "browser") return false;
+	return 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
+exports.isTossEnvironment = isTossEnvironment;
+exports.isTossEnvironmentCached = isTossEnvironmentCached;
+exports.loadTossSdk = loadTossSdk;
+exports.resetDetection = resetDetection;
+
+//# sourceMappingURL=detect.cjs.map

package/dist/detect.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.cjs","names":[],"sources":["../src/detect.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"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,IAAI;;;;AAKJ,SAAgB,iBAAuB;AACrC,UAAS,KAAA;;;;;;;;;;;AAYX,SAAgB,0BAA+C;CAC7D,MAAM,QAAQ,WAAW;AACzB,KAAI,UAAU,OAAQ,QAAO;AAC7B,KAAI,UAAU,UAAW,QAAO;AAChC,QAAO;;;;;;;;;AAUT,eAAsB,oBAAsC;CAG1D,MAAM,QAAQ,WAAW;AACzB,KAAI,UAAU,OAAQ,QAAO;AAC7B,KAAI,UAAU,UAAW,QAAO;AAEhC,KAAI,WAAW,KAAA,EAAW,QAAO;CAEjC,MAAM,MAAM,MAAM,aAAa;AAC/B,KAAI,OAAO,KAAK,yBAAyB,YAAY;AACnD,WAAS;AACT,SAAO;;AAKT,KAAI;EACF,MAAM,UAAU,IAAI,sBAAsB;AAC1C,WAAS,QAAQ,QAAQ,IAAI,OAAO,YAAY;SAC1C;AACN,WAAS;;AAEX,QAAO;;;;;;AAOT,eAAsB,cAA4E;AAChG,KAAI;AACF,SAAO,MAAM,OAAO;SACd;AACN,SAAO"}

package/dist/detect.d.cts

@@ -0,0 +1,50 @@
+import * as _$_apps_in_toss_web_framework0 from "@apps-in-toss/web-framework";
+
+//#region src/detect.d.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.
+ */
+/**
+ * Reset the cached detection result. Primarily for tests.
+ */
+declare function resetDetection(): void;
+/**
+ * Synchronous read of the cached detection result. Returns:
+ *   - `true` / `false` if an override is active or the async detection has
+ *     already resolved
+ *   - `undefined` if detection hasn't run yet
+ *
+ * Used by spec-sync APIs (e.g. `navigator.canShare`) that can't `await`
+ * detection.
+ */
+declare function isTossEnvironmentCached(): boolean | undefined;
+/**
+ * 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.
+ */
+declare function isTossEnvironment(): Promise<boolean>;
+/**
+ * Lazy SDK accessor — returns the module if available, else `null`. Callers
+ * are expected to `await` and null-check. Never throws.
+ */
+declare function loadTossSdk(): Promise<typeof _$_apps_in_toss_web_framework0 | null>;
+//#endregion
+export { isTossEnvironment, isTossEnvironmentCached, loadTossSdk, resetDetection };
+//# sourceMappingURL=detect.d.cts.map

package/dist/detect.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.cts","names":[],"sources":["../src/detect.ts"],"mappings":";;;;;;AAuBA;;;;;AAaA;;;;;AAcA;;;;;AA8BA;;iBAzDgB,cAAA,CAAA;;;;;;;;;;iBAaA,uBAAA,CAAA;;;;;;;;iBAcM,iBAAA,CAAA,GAAqB,OAAA;;;;;iBA8BrB,WAAA,CAAA,GAAe,OAAA,QAAJ,8BAAA"}