Create new browserSupportsPasskeys helper

Author: MasterKale

packages/browser/src/helpers/browserSupportsPasskeys.test.ts

@@ -0,0 +1,77 @@
+/// <reference lib="DOM" />
+import { assert, assertFalse } from '@std/assert';
+import { returnsNext, stub } from '@std/testing/mock';
+import { browserSupportsPasskeys } from './browserSupportsPasskeys.ts';
+import { _getBrowserCapabilitiesInternals } from './getBrowserCapabilities.ts';
+
+Deno.test('Returns true when passkeyPlatformAuthenticator capability is supported', async () => {
+  // @ts-ignore: Setting up global state
+  globalThis.PublicKeyCredential = () => {};
+
+  const mockGetBrowserCapabilities = stub(
+    _getBrowserCapabilitiesInternals,
+    'stubThis',
+    // @ts-ignore: Keeping tests lean
+    returnsNext([{ passkeyPlatformAuthenticator: 'supported' }]),
+  );
+
+  const supported = await browserSupportsPasskeys();
+
+  assert(supported);
+
+  mockGetBrowserCapabilities.restore();
+});
+
+Deno.test('Returns true when userVerifyingPlatformAuthenticator capability is supported', async () => {
+  // @ts-ignore: Setting up global state
+  globalThis.PublicKeyCredential = () => {};
+
+  const mockGetBrowserCapabilities = stub(
+    _getBrowserCapabilitiesInternals,
+    'stubThis',
+    // @ts-ignore: Keeping tests lean
+    returnsNext([{ userVerifyingPlatformAuthenticator: 'supported' }]),
+  );
+
+  const supported = await browserSupportsPasskeys();
+
+  assert(supported);
+
+  mockGetBrowserCapabilities.restore();
+});
+
+Deno.test('Returns true when hybridTransport capability is supported', async () => {
+  // @ts-ignore: Setting up global state
+  globalThis.PublicKeyCredential = () => {};
+
+  const mockGetBrowserCapabilities = stub(
+    _getBrowserCapabilitiesInternals,
+    'stubThis',
+    // @ts-ignore: Keeping tests lean
+    returnsNext([{ hybridTransport: 'supported' }]),
+  );
+
+  const supported = await browserSupportsPasskeys();
+
+  assert(supported);
+
+  mockGetBrowserCapabilities.restore();
+});
+
+Deno.test('Returns false when no relevant capabilities are supported', async () => {
+  // @ts-ignore: Setting up global state
+  globalThis.PublicKeyCredential = () => {};
+
+  const mockGetBrowserCapabilities = stub(
+    _getBrowserCapabilitiesInternals,
+    'stubThis',
+    // @ts-ignore: Keeping tests lean
+    returnsNext([{}]),
+  );
+
+  const supported = await browserSupportsPasskeys();
+
+  assertFalse(supported);
+
+  mockGetBrowserCapabilities.restore();
+});

packages/browser/src/helpers/browserSupportsPasskeys.ts

@@ -0,0 +1,24 @@
+import { browserSupportsWebAuthn } from './browserSupportsWebAuthn.ts';
+import { getBrowserCapabilities } from './getBrowserCapabilities.ts';
+
+/**
+ * Determine if the browser is capable of facilitating use of synced passkeys for **authentication**
+ * via local platform authenticator or via the hybrid transport. This method does NOT know if the
+ * user actually has a passkey available to use.
+ */
+export async function browserSupportsPasskeys(): Promise<boolean> {
+  if (!browserSupportsWebAuthn()) {
+    return new Promise((resolve) => resolve(false));
+  }
+
+  const capabilities = await getBrowserCapabilities();
+  const {
+    passkeyPlatformAuthenticator,
+    userVerifyingPlatformAuthenticator,
+    hybridTransport,
+  } = capabilities;
+
+  return passkeyPlatformAuthenticator === 'supported' ||
+    hybridTransport === 'supported' ||
+    userVerifyingPlatformAuthenticator === 'supported';
+}

packages/browser/src/index.ts

@@ -1,6 +1,7 @@
 export * from './methods/startRegistration.ts';
 export * from './methods/startAuthentication.ts';
 export * from './helpers/browserSupportsWebAuthn.ts';
+export * from './helpers/browserSupportsPasskeys.ts';
 export * from './helpers/platformAuthenticatorIsAvailable.ts';
 export * from './helpers/browserSupportsWebAuthnAutofill.ts';
 export * from './helpers/base64URLStringToBuffer.ts';