electron-webauthn 0.0.17 → 1.0.0

package/dist/create/authorization-controller.js

@@ -4,7 +4,6 @@ import { NSArrayFromObjects } from "../objc/foundation/nsarray.js";
 import { NSStringFromString } from "../objc/foundation/nsstring.js";
 import { createASCPublicKeyCredentialDescriptor } from "../objc/authentication-services/as-authorization-c-public-key-credential-descriptor.js";
 import { NSNumberFromInteger } from "../objc/foundation/nsinteger.js";
-import { isNumber, isObject } from "../helpers/validation.js";
 const createControllerState = new Map();
 function getObjectPointerString(self) {
     return getPointer(self).toBase64();
@@ -32,7 +31,13 @@ export const WebauthnCreateController = NobjcClass.define({
                 const context = NobjcClass.super(self, "_requestContextWithRequests$error$", requests, outError);
                 const selfPointer = getObjectPointerString(self);
                 if (context && createControllerState.has(selfPointer)) {
-                    const registrationOptions = context.platformKeyCredentialCreationOptions();
+                    let isSecurityKey = false;
+                    let registrationOptions = context.platformKeyCredentialCreationOptions();
+                    if (!registrationOptions) {
+                        registrationOptions =
+                            context.securityKeyCredentialCreationOptions();
+                        isSecurityKey = true;
+                    }
                     const [clientDataHash, pubKeyCredParams, residentKeyRequired, excludeCredentials,] = createControllerState.get(selfPointer);
                     registrationOptions.setClientDataHash$(NSDataFromBuffer(clientDataHash));
                     registrationOptions.setChallenge$(null);
@@ -45,7 +50,9 @@ export const WebauthnCreateController = NobjcClass.define({
                     if (supportedAlgos.length > 0) {
                         registrationOptions.setSupportedAlgorithmIdentifiers$(NSArrayFromObjects(supportedAlgos));
                     }
-                    registrationOptions.setShouldRequireResidentKey$(residentKeyRequired);
+                    if (!isSecurityKey) {
+                        registrationOptions.setShouldRequireResidentKey$(residentKeyRequired);
+                    }
                     const excludeList = [];
                     for (const cred of excludeCredentials) {
                         const transports = [];

package/dist/create/handler.d.ts

@@ -35,6 +35,7 @@ interface CreateCredentialSuccessResult {
 interface CreateCredentialErrorResult {
     success: false;
     error: "TypeError" | "AbortError" | "NotAllowedError" | "SecurityError" | "InvalidStateError";
+    errorObject?: Error;
 }
 export type CreateCredentialResult = CreateCredentialSuccessResult | CreateCredentialErrorResult;
 export declare function createCredential(publicKeyOptions: PublicKeyCredentialCreationOptions | undefined, additionalOptions: WebauthnCreateRequestOptions): Promise<CreateCredentialResult>;

package/dist/create/handler.js

@@ -108,6 +108,16 @@ export async function createCredential(publicKeyOptions, additionalOptions) {
             return { success: false, error: "TypeError" };
         }
     }
+    if (supportedAlgorithmIdentifiers.length === 0) {
+        supportedAlgorithmIdentifiers.push({
+            type: "public-key",
+            algorithm: -7,
+        });
+        supportedAlgorithmIdentifiers.push({
+            type: "public-key",
+            algorithm: -257,
+        });
+    }
     const excludeCredentials = [];
     if (publicKeyOptions.excludeCredentials &&
         Array.isArray(publicKeyOptions.excludeCredentials)) {
@@ -128,6 +138,7 @@ export async function createCredential(publicKeyOptions, additionalOptions) {
     const { extensions, largeBlobSupport, prf } = getExtensionsConfiguration(publicKeyOptions.extensions);
     let residentKeyRequired = false;
     let userVerificationPreference = "preferred";
+    let preferredAuthenticatorAttachment = "all";
     if (publicKeyOptions.authenticatorSelection) {
         if (publicKeyOptions.authenticatorSelection.residentKey === "required") {
             residentKeyRequired = true;
@@ -145,6 +156,13 @@ export async function createCredential(publicKeyOptions, additionalOptions) {
         else {
             userVerificationPreference = "preferred";
         }
+        const attachment = publicKeyOptions.authenticatorSelection.authenticatorAttachment;
+        if (attachment === "cross-platform") {
+            preferredAuthenticatorAttachment = "cross-platform";
+        }
+        else if (attachment === "platform") {
+            preferredAuthenticatorAttachment = "platform";
+        }
     }
     const { currentOrigin, topFrameOrigin, isPublicSuffix, nativeWindowHandle } = additionalOptions;
     const isRpIdAllowed = isRpIdAllowedForOrigin(currentOrigin, rpId, {
@@ -153,13 +171,13 @@ export async function createCredential(publicKeyOptions, additionalOptions) {
     if (!isRpIdAllowed.ok) {
         return { success: false, error: "NotAllowedError" };
     }
-    const result = await createCredentialInternal(rpId, challenge, userName, userID, nativeWindowHandle, currentOrigin, extensions, attestationPreference, supportedAlgorithmIdentifiers, excludeCredentials, residentKeyRequired, userVerificationPreference, {
+    let errorResult = null;
+    const result = await createCredentialInternal(rpId, challenge, userName, userID, nativeWindowHandle, currentOrigin, timeout, extensions, attestationPreference, supportedAlgorithmIdentifiers, excludeCredentials, residentKeyRequired, preferredAuthenticatorAttachment, userVerificationPreference, {
         topFrameOrigin,
         largeBlobSupport,
         prf,
     }).catch((error) => {
-        console.error("Error creating credential", error);
-        console.log("error.message", error.message);
+        errorResult = error;
         if (error.message.includes("(com.apple.AuthenticationServices.AuthorizationError error 1006.)")) {
             return "InvalidStateError";
         }
@@ -169,7 +187,7 @@ export async function createCredential(publicKeyOptions, additionalOptions) {
         return null;
     });
     if (typeof result === "string") {
-        return { success: false, error: result };
+        return { success: false, error: result, errorObject: errorResult };
     }
     const data = {
         credentialId: bufferToBase64Url(result.credentialId),

package/dist/create/internal-handler.d.ts

@@ -1,5 +1,6 @@
 import { type PRFInput } from "../helpers/prf.js";
 import { type PublicKeyCredentialParams } from "./authorization-controller.js";
+export type AuthenticatorAttachmentWithExtra = AuthenticatorAttachment | "all";
 export interface CreateCredentialResult {
     credentialId: Buffer;
     clientDataJSON: Buffer;
@@ -30,5 +31,5 @@ export interface ExcludeCredential {
     id: Buffer;
     transports?: string[];
 }
-declare function createCredentialInternal(rpid: string, challenge: Buffer, username: string, userID: Buffer, nativeWindowHandle: Buffer, origin: string, enabledExtensions: CredentialCreationExtensions[], attestation: CredentialAttestationPreference, supportedAlgorithmIdentifiers: PublicKeyCredentialParams[], excludeCredentials: ExcludeCredential[], residentKeyRequired?: boolean, userVerification?: CredentialUserVerificationPreference, additionalOptions?: CreateCredentialAdditionalOptions): Promise<CreateCredentialResult>;
+declare function createCredentialInternal(rpid: string, challenge: Buffer, username: string, userID: Buffer, nativeWindowHandle: Buffer, origin: string, timeout: number, enabledExtensions: CredentialCreationExtensions[], attestation: CredentialAttestationPreference, supportedAlgorithmIdentifiers: PublicKeyCredentialParams[], excludeCredentials: ExcludeCredential[], residentKeyRequired?: boolean, preferredAuthenticatorAttachment?: AuthenticatorAttachmentWithExtra, userVerification?: CredentialUserVerificationPreference, additionalOptions?: CreateCredentialAdditionalOptions): Promise<CreateCredentialResult>;
 export { createCredentialInternal };

package/dist/create/internal-handler.js

@@ -17,16 +17,11 @@ import { NSStringFromString } from "../objc/foundation/nsstring.js";
 import { removeControllerState, setControllerState, WebauthnCreateController, } from "./authorization-controller.js";
 import { parseAttestationObject } from "@oslojs/webauthn";
 import { ASAuthorizationPublicKeyCredentialAttachment } from "../objc/authentication-services/enums/as-authorization-public-key-credential-attachment.js";
+import { createSecurityKeyPublicKeyCredentialProvider } from "../objc/authentication-services/as-authorization-security-key-public-key-credential-provider.js";
+import { createASAuthorizationPublicKeyCredentialParameters, } from "../objc/authentication-services/as-authorization-public-key-credential-parameters.js";
 const VALID_EXTENSIONS = ["largeBlob", "prf"];
-function createCredentialInternal(rpid, challenge, username, userID, nativeWindowHandle, origin, enabledExtensions, attestation = "none", supportedAlgorithmIdentifiers = [], excludeCredentials, residentKeyRequired = false, userVerification = "preferred", additionalOptions = {}) {
-    const { promise, resolve, reject } = PromiseWithResolvers();
-    const NS_rpID = NSStringFromString(rpid);
-    const NS_challenge = NSDataFromBuffer(challenge);
-    const NS_username = NSStringFromString(username);
-    const NS_userID = NSDataFromBuffer(userID);
-    const platformProvider = createPlatformPublicKeyCredentialProvider(NS_rpID);
-    const platformKeyRequest = platformProvider.createCredentialRegistrationRequestWithChallenge$name$userID$(NS_challenge, NS_username, NS_userID);
-    if (enabledExtensions.includes("largeBlob")) {
+function setupPublicKeyCredentialRegistrationRequest(type, keyRequest, attestation, enabledExtensions, userVerification, pubKeyCredParams, additionalOptions) {
+    if (type === "platform" && enabledExtensions.includes("largeBlob")) {
         let supportMode;
         const largeBlobSupport = additionalOptions.largeBlobSupport;
         if (largeBlobSupport === "required") {
@@ -42,11 +37,25 @@ function createCredentialInternal(rpid, challenge, username, userID, nativeWindo
         }
         if (supportMode) {
             const largeBlobInput = createASAuthorizationPublicKeyCredentialLargeBlobRegistrationInput(supportMode);
-            platformKeyRequest.setLargeBlob$(largeBlobInput);
+            keyRequest.setLargeBlob$(largeBlobInput);
         }
     }
     let attestationPreference = ASAuthorizationPublicKeyCredentialAttestationKind.None;
-    platformKeyRequest.setAttestationPreference$(NSStringFromString(attestationPreference));
+    if (type === "security-key") {
+        if (attestation === "direct") {
+            attestationPreference =
+                ASAuthorizationPublicKeyCredentialAttestationKind.Direct;
+        }
+        else if (attestation === "enterprise") {
+            attestationPreference =
+                ASAuthorizationPublicKeyCredentialAttestationKind.Enterprise;
+        }
+        else if (attestation === "indirect") {
+            attestationPreference =
+                ASAuthorizationPublicKeyCredentialAttestationKind.Indirect;
+        }
+    }
+    keyRequest.setAttestationPreference$(NSStringFromString(attestationPreference));
     let userVerificationPreference = ASAuthorizationPublicKeyCredentialUserVerificationPreference.Preferred;
     if (userVerification === "required") {
         userVerificationPreference =
@@ -56,28 +65,67 @@ function createCredentialInternal(rpid, challenge, username, userID, nativeWindo
         userVerificationPreference =
             ASAuthorizationPublicKeyCredentialUserVerificationPreference.Discouraged;
     }
-    platformKeyRequest.setUserVerificationPreference$(NSStringFromString(userVerificationPreference));
-    if (additionalOptions.userDisplayName) {
+    keyRequest.setUserVerificationPreference$(NSStringFromString(userVerificationPreference));
+    if (type === "platform" && additionalOptions.userDisplayName) {
         const userDisplayName = NSStringFromString(additionalOptions.userDisplayName);
-        platformKeyRequest.setDisplayName$(userDisplayName);
+        keyRequest.setDisplayName$(userDisplayName);
     }
-    if (enabledExtensions.includes("prf")) {
+    if (type === "security-key") {
+        const credentialParameters = [];
+        for (const param of pubKeyCredParams) {
+            if (param.type === "public-key") {
+                credentialParameters.push(createASAuthorizationPublicKeyCredentialParameters(param.algorithm));
+            }
+        }
+        const nsCredentialParameters = NSArrayFromObjects(credentialParameters);
+        keyRequest.setCredentialParameters$(nsCredentialParameters);
+    }
+    if (type === "platform" && enabledExtensions.includes("prf")) {
         if (additionalOptions.prf) {
             const inputValues = createPRFInput(additionalOptions.prf);
             const prfInput = createASAuthorizationPublicKeyCredentialPRFRegistrationInput(inputValues);
-            platformKeyRequest.setPrf$(prfInput);
+            keyRequest.setPrf$(prfInput);
         }
         else {
-            platformKeyRequest.setPrf$(ASAuthorizationPublicKeyCredentialPRFRegistrationInput.checkForSupport());
+            keyRequest.setPrf$(ASAuthorizationPublicKeyCredentialPRFRegistrationInput.checkForSupport());
         }
     }
-    const requestsArray = NSArrayFromObjects([platformKeyRequest]);
+}
+function createCredentialInternal(rpid, challenge, username, userID, nativeWindowHandle, origin, timeout, enabledExtensions, attestation = "none", supportedAlgorithmIdentifiers = [], excludeCredentials, residentKeyRequired = false, preferredAuthenticatorAttachment = "all", userVerification = "preferred", additionalOptions = {}) {
+    const { promise, resolve, reject } = PromiseWithResolvers();
+    const NS_rpID = NSStringFromString(rpid);
+    const NS_challenge = NSDataFromBuffer(challenge);
+    const NS_username = NSStringFromString(username);
+    const NS_userID = NSDataFromBuffer(userID);
+    const requestArrayInput = [];
+    if (preferredAuthenticatorAttachment === "all" ||
+        preferredAuthenticatorAttachment === "platform") {
+        const platformProvider = createPlatformPublicKeyCredentialProvider(NS_rpID);
+        const platformKeyRequest = platformProvider.createCredentialRegistrationRequestWithChallenge$name$userID$(NS_challenge, NS_username, NS_userID);
+        setupPublicKeyCredentialRegistrationRequest("platform", platformKeyRequest, attestation, enabledExtensions, userVerification, supportedAlgorithmIdentifiers, additionalOptions);
+        requestArrayInput.push(platformKeyRequest);
+    }
+    if (preferredAuthenticatorAttachment === "all" ||
+        preferredAuthenticatorAttachment === "cross-platform") {
+        const securityKeyProvider = createSecurityKeyPublicKeyCredentialProvider(NS_rpID);
+        const securityKeyRequest = securityKeyProvider.createCredentialRegistrationRequestWithChallenge$displayName$name$userID$(NS_challenge, NSStringFromString(additionalOptions.userDisplayName || username), NS_username, NS_userID);
+        setupPublicKeyCredentialRegistrationRequest("security-key", securityKeyRequest, attestation, enabledExtensions, userVerification, supportedAlgorithmIdentifiers, additionalOptions);
+        requestArrayInput.push(securityKeyRequest);
+    }
+    const requestsArray = NSArrayFromObjects(requestArrayInput);
     const authController = WebauthnCreateController.alloc().initWithAuthorizationRequests$(requestsArray);
     const clientData = generateWebauthnClientData("webauthn.create", origin, challenge, additionalOptions.topFrameOrigin);
     const { clientDataHash, clientDataBuffer } = generateClientDataInfo(clientData);
     setControllerState(authController, clientDataHash, supportedAlgorithmIdentifiers, residentKeyRequired, excludeCredentials);
+    let isFinished = false;
+    let timeoutHandlerId = null;
     const finished = (_success) => {
+        isFinished = true;
         removeControllerState(authController);
+        if (timeoutHandlerId) {
+            clearTimeout(timeoutHandlerId);
+            timeoutHandlerId = null;
+        }
     };
     const delegate = createAuthorizationControllerDelegate({
         didCompleteWithAuthorization: (_, authorization) => {
@@ -140,7 +188,6 @@ function createCredentialInternal(rpid, challenge, username, userID, nativeWindo
         didCompleteWithError: (_, error) => {
             const parsedError = error;
             const errorMessage = parsedError.localizedDescription().UTF8String();
-            console.error("Authorization failed:", errorMessage);
             reject(new Error(errorMessage));
             finished(false);
         },
@@ -149,6 +196,11 @@ function createCredentialInternal(rpid, challenge, username, userID, nativeWindo
     const presentationContextProvider = createPresentationContextProviderFromNativeWindowHandle(nativeWindowHandle);
     authController.setPresentationContextProvider$(presentationContextProvider);
     authController.performRequests();
+    timeoutHandlerId = setTimeout(() => {
+        if (isFinished)
+            return;
+        authController.cancel();
+    }, timeout);
     return promise;
 }
 export { createCredentialInternal };

package/dist/get/authorization-controller.js

@@ -22,7 +22,10 @@ export const WebauthnGetController = NobjcClass.define({
                 const context = NobjcClass.super(self, "_requestContextWithRequests$error$", requests, outError);
                 const selfPointer = getObjectPointerString(self);
                 if (getControllerState.has(selfPointer)) {
-                    const assertionOptions = context.platformKeyCredentialAssertionOptions();
+                    let assertionOptions = context.platformKeyCredentialAssertionOptions();
+                    if (!assertionOptions) {
+                        assertionOptions = context.securityKeyCredentialAssertionOptions();
+                    }
                     const clientDataHash = getControllerState.get(selfPointer);
                     assertionOptions.setClientDataHash$(NSDataFromBuffer(clientDataHash));
                     context.setPlatformKeyCredentialAssertionOptions$(assertionOptions.copyWithZone$(null));

package/dist/get/handler.d.ts

@@ -30,6 +30,7 @@ interface GetCredentialSuccessResult {
 interface GetCredentialErrorResult {
     success: false;
     error: "TypeError" | "AbortError" | "NotAllowedError" | "SecurityError";
+    errorObject?: Error;
 }
 export type GetCredentialResult = GetCredentialSuccessResult | GetCredentialErrorResult;
 export declare function getCredential(publicKeyOptions: PublicKeyCredentialRequestOptions | undefined, additionalOptions: WebauthnGetRequestOptions): Promise<GetCredentialResult>;

package/dist/get/handler.js

@@ -95,23 +95,21 @@ export async function getCredential(publicKeyOptions, additionalOptions) {
     if (!isRpIdAllowed.ok) {
         return { success: false, error: "NotAllowedError" };
     }
-    const result = await getCredentialInternal(rpId, challenge, nativeWindowHandle, currentOrigin, enabledExtensions, allowedCredentialsArray, userVerification, {
+    let errorResult = null;
+    const result = await getCredentialInternal(rpId, challenge, nativeWindowHandle, currentOrigin, timeout, enabledExtensions, allowedCredentialsArray, userVerification, {
         topFrameOrigin,
         largeBlobDataToWrite: largeBlobWriteBuffer,
         prf,
         prfByCredential,
     }).catch((error) => {
-        console.error("Error getting credential", error);
+        errorResult = error;
         if (error.message.startsWith("The operation couldn’t be completed.")) {
             return "NotAllowedError";
         }
         return "NotAllowedError";
     });
     if (typeof result === "string") {
-        if (result === "NotAllowedError") {
-            return { success: false, error: "NotAllowedError" };
-        }
-        return { success: false, error: "NotAllowedError" };
+        return { success: false, error: result, errorObject: errorResult };
     }
     const data = {
         credentialId: bufferToBase64Url(result.id),

package/dist/get/internal-handler.d.ts

@@ -1,5 +1,5 @@
 import { type PRFInput } from "../helpers/prf.js";
-type AuthenticatorAttachment = "platform" | "cross-platform";
+import type { AuthenticatorAttachment } from "../helpers/types.js";
 export type UserVerificationPreference = "preferred" | "required" | "discouraged";
 declare const VALID_EXTENSIONS: readonly ["largeBlobRead", "largeBlobWrite", "prf"];
 export type CredentialAssertionExtensions = (typeof VALID_EXTENSIONS)[number];
@@ -20,5 +20,5 @@ export interface GetCredentialAdditionalOptions {
     prfByCredential?: Record<string, PRFInput>;
     topFrameOrigin?: string;
 }
-declare function getCredentialInternal(rpid: string, challenge: Buffer, nativeWindowHandle: Buffer, origin: string, enabledExtensions: CredentialAssertionExtensions[], allowedCredentialIds: Buffer[], userVerificationPreference?: UserVerificationPreference, additionalOptions?: GetCredentialAdditionalOptions): Promise<GetCredentialResult>;
+declare function getCredentialInternal(rpid: string, challenge: Buffer, nativeWindowHandle: Buffer, origin: string, timeout: number, enabledExtensions: CredentialAssertionExtensions[], allowedCredentialIds: Buffer[], userVerificationPreference?: UserVerificationPreference, additionalOptions?: GetCredentialAdditionalOptions): Promise<GetCredentialResult>;
 export { getCredentialInternal };

package/dist/get/internal-handler.js

@@ -76,7 +76,7 @@ function setupPublicKeyCredentialRequest(type, keyRequest, userVerificationPrefe
         }
     }
 }
-function getCredentialInternal(rpid, challenge, nativeWindowHandle, origin, enabledExtensions = [], allowedCredentialIds, userVerificationPreference, additionalOptions = {}) {
+function getCredentialInternal(rpid, challenge, nativeWindowHandle, origin, timeout, enabledExtensions = [], allowedCredentialIds, userVerificationPreference, additionalOptions = {}) {
     const { promise, resolve, reject } = PromiseWithResolvers();
     const NS_rpID = NSStringFromString(rpid);
     const NS_challenge = NSDataFromBuffer(challenge);
@@ -94,8 +94,15 @@ function getCredentialInternal(rpid, challenge, nativeWindowHandle, origin, enab
     const clientData = generateWebauthnClientData("webauthn.get", origin, challenge, additionalOptions.topFrameOrigin);
     const { clientDataHash, clientDataBuffer } = generateClientDataInfo(clientData);
     setClientDataHash(authController, clientDataHash);
+    let isFinished = false;
+    let timeoutHandlerId = null;
     const finished = (_success) => {
+        isFinished = true;
         removeClientDataHash(authController);
+        if (timeoutHandlerId) {
+            clearTimeout(timeoutHandlerId);
+            timeoutHandlerId = null;
+        }
     };
     if (allowedCredentialIds.length > 0) {
         const allowedCredentials = NSArrayFromObjects(allowedCredentialIds.map((id) => createPlatformPublicKeyCredentialDescriptor(NSDataFromBuffer(id))));
@@ -152,6 +159,11 @@ function getCredentialInternal(rpid, challenge, nativeWindowHandle, origin, enab
     const presentationContextProvider = createPresentationContextProviderFromNativeWindowHandle(nativeWindowHandle);
     authController.setPresentationContextProvider$(presentationContextProvider);
     authController.performRequests();
+    timeoutHandlerId = setTimeout(() => {
+        if (isFinished)
+            return;
+        authController.cancel();
+    }, timeout);
     return promise;
 }
 export { getCredentialInternal };

package/dist/helpers/types.d.ts

@@ -0,0 +1 @@
+export type AuthenticatorAttachment = "platform" | "cross-platform";

package/dist/helpers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/objc/authentication-services/as-authorization-public-key-credential-parameters.d.ts

@@ -0,0 +1,8 @@
+import type { NobjcObject } from "objc-js";
+declare class _ASAuthorizationPublicKeyCredentialParameters extends NobjcObject {
+    initWithAlgorithm$(algorithm: number): _ASAuthorizationPublicKeyCredentialParameters;
+    algorithm(): number;
+}
+export declare const ASAuthorizationPublicKeyCredentialParameters: typeof _ASAuthorizationPublicKeyCredentialParameters;
+export type { _ASAuthorizationPublicKeyCredentialParameters };
+export declare function createASAuthorizationPublicKeyCredentialParameters(algorithm: number): _ASAuthorizationPublicKeyCredentialParameters;

package/dist/objc/authentication-services/as-authorization-public-key-credential-parameters.js

@@ -0,0 +1,6 @@
+import { AuthenticationServices } from "./index.js";
+export const ASAuthorizationPublicKeyCredentialParameters = AuthenticationServices.ASAuthorizationPublicKeyCredentialParameters;
+export function createASAuthorizationPublicKeyCredentialParameters(algorithm) {
+    const instance = ASAuthorizationPublicKeyCredentialParameters.alloc();
+    return instance.initWithAlgorithm$(algorithm);
+}

package/dist/objc/authentication-services/as-authorization-security-key-public-key-credential-provider.d.ts

@@ -1,7 +1,9 @@
+import type { _NSData } from "../foundation/nsdata.js";
+import type { _NSString } from "../foundation/nsstring.js";
 import type { NobjcObject } from "objc-js";
 declare class _ASAuthorizationSecurityKeyPublicKeyCredentialProvider extends NobjcObject {
     initWithRelyingPartyIdentifier$(relyingPartyIdentifier: NobjcObject): _ASAuthorizationSecurityKeyPublicKeyCredentialProvider;
-    createCredentialRegistrationRequestWithChallenge$name$userID$(challenge: NobjcObject, name: NobjcObject, userID: NobjcObject): NobjcObject;
+    createCredentialRegistrationRequestWithChallenge$displayName$name$userID$(challenge: _NSData, displayName: _NSString, name: _NSString, userID: _NSData): NobjcObject;
     createCredentialAssertionRequestWithChallenge$(challenge: NobjcObject): NobjcObject;
 }
 export declare const ASAuthorizationSecurityKeyPublicKeyCredentialProvider: typeof _ASAuthorizationSecurityKeyPublicKeyCredentialProvider;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "electron-webauthn",
-  "version": "0.0.17",
+  "version": "1.0.0",
   "repository": "https://github.com/iamEvanYT/electron-webauthn.git",
+  "homepage": "https://github.com/iamEvanYT/electron-webauthn#readme",
   "description": "Add support for WebAuthn for Electron.",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -18,7 +19,7 @@
   ],
   "type": "module",
   "scripts": {
-    "build": "tsc && rm -rf dist/test",
+    "build": "rm -rf dist && tsc && rm -rf dist/test",
     "test": "bun run src/test/index.ts"
   },
   "devDependencies": {
@@ -29,7 +30,7 @@
   },
   "dependencies": {
     "@oslojs/webauthn": "^1.0.0",
-    "objc-js": "^0.0.15"
+    "objc-js": "^1.0.0"
   },
   "trustedDependencies": [
     "objc-js"