electron-webauthn 0.0.5 → 0.0.6

package/dist/objc/foundation/nsarray.js

@@ -0,0 +1,15 @@
+import { Foundation } from "./index.js";
+export const NSArray = Foundation.NSArray;
+// Helper Functions
+/**
+ * Create an NSArray from an array of objects
+ * @param objects The array of objects
+ * @returns An NSArray object
+ */
+export function NSArrayFromObjects(objects) {
+    let array = NSArray.array();
+    for (const obj of objects) {
+        array = array.arrayByAddingObject$(obj);
+    }
+    return array;
+}

package/dist/objc/foundation/nsdata.js

@@ -0,0 +1,119 @@
+import { Foundation } from "./index.js";
+import { NSString } from "./nsstring.js";
+export const NSData = Foundation.NSData;
+// Helper Functions
+/**
+ * Create NSData from a JavaScript Buffer
+ * @param buffer The Buffer object
+ * @returns An NSData object
+ */
+export function NSDataFromBuffer(buffer) {
+    return NSData.dataWithBytes$length$(buffer, buffer.length);
+}
+/**
+ * Convert NSData to a JavaScript Buffer using base64 encoding
+ * This is the most reliable method for data conversion.
+ * @param data The NSData object
+ * @returns A Buffer containing the data
+ */
+export function bufferFromNSData(data) {
+    const nsData = data;
+    const length = nsData.length();
+    if (length === 0) {
+        return Buffer.alloc(0);
+    }
+    // Use base64 encoding as a reliable bridge between NSData and JS Buffer
+    const base64String = nsData.base64EncodedStringWithOptions$(0);
+    const base64Str = base64String.UTF8String();
+    return Buffer.from(base64Str, "base64");
+}
+/**
+ * Convert NSData to a JavaScript Buffer using direct memory copy
+ * This method uses getBytes:length: for direct memory access.
+ * May be more efficient for large data, but requires proper buffer allocation.
+ * @param data The NSData object
+ * @returns A Buffer containing the data
+ */
+export function bufferFromNSDataDirect(data) {
+    const nsData = data;
+    const length = nsData.length();
+    if (length === 0) {
+        return Buffer.alloc(0);
+    }
+    // Allocate a buffer and copy bytes directly
+    const buffer = Buffer.alloc(length);
+    nsData.getBytes$length$(buffer, length);
+    return buffer;
+}
+/**
+ * Convert NSData to a JavaScript Uint8Array
+ * @param data The NSData object
+ * @returns A Uint8Array containing the data
+ */
+export function uint8ArrayFromNSData(data) {
+    const buffer = bufferFromNSData(data);
+    return new Uint8Array(buffer);
+}
+/**
+ * Convert NSData to a base64 string
+ * @param data The NSData object
+ * @returns A base64-encoded string
+ */
+export function base64FromNSData(data) {
+    const nsData = data;
+    const nsString = nsData.base64EncodedStringWithOptions$(0);
+    return nsString.UTF8String();
+}
+/**
+ * Create NSData from a base64 string
+ * @param base64String The base64-encoded string
+ * @returns An NSData object
+ */
+export function NSDataFromBase64(base64String) {
+    const nsString = NSString.stringWithUTF8String$(base64String);
+    const nsData = NSData.alloc();
+    return nsData.initWithBase64EncodedString$options$(nsString, 0);
+}
+/**
+ * Get the length of NSData
+ * @param data The NSData object
+ * @returns The length in bytes
+ */
+export function NSDataLength(data) {
+    const nsData = data;
+    return nsData.length();
+}
+/**
+ * Create a copy of NSData
+ * @param data The NSData object
+ * @returns A new NSData object with copied data
+ */
+export function NSDataCopy(data) {
+    return NSData.dataWithData$(data);
+}
+/**
+ * Compare two NSData objects for equality
+ * @param data1 The first NSData object
+ * @param data2 The second NSData object
+ * @returns True if the data is equal
+ */
+export function NSDataIsEqual(data1, data2) {
+    const nsData1 = data1;
+    return nsData1.isEqualToData$(data2);
+}
+/**
+ * Extract a subrange of NSData
+ * Note: This method may not work with all versions of nobjc due to NSRange struct limitations.
+ * As an alternative, convert to Buffer, slice, and convert back.
+ * @param data The NSData object
+ * @param location The starting position
+ * @param length The number of bytes to extract
+ * @returns A new NSData object containing the subdata
+ */
+export function NSDataSubdata(data, location, length) {
+    // Workaround: Convert to buffer, slice, and convert back
+    // This avoids the NSRange struct issue with nobjc
+    const buffer = bufferFromNSData(data);
+    const slicedBuffer = buffer.subarray(location, location + length);
+    return NSDataFromBuffer(slicedBuffer);
+}

package/dist/objc/foundation/nserror.js

@@ -0,0 +1,70 @@
+import { Foundation } from "./index.js";
+import {} from "./nsstring.js";
+export const NSError = Foundation.NSError;
+/**
+ * Parse an NSError object into a JavaScript-friendly format
+ * @param error The NSError object
+ * @returns An object containing the error details
+ */
+export function parseNSError(error) {
+    const nsError = error;
+    const domain = nsError.domain().UTF8String();
+    const code = nsError.code();
+    const localizedDescription = nsError.localizedDescription().UTF8String();
+    // Optional properties that may be null
+    let localizedFailureReason;
+    try {
+        const reason = nsError.localizedFailureReason();
+        if (reason) {
+            localizedFailureReason = reason.UTF8String();
+        }
+    }
+    catch (e) {
+        // Property may not exist or be null
+    }
+    let localizedRecoverySuggestion;
+    try {
+        const suggestion = nsError.localizedRecoverySuggestion();
+        if (suggestion) {
+            localizedRecoverySuggestion = suggestion.UTF8String();
+        }
+    }
+    catch (e) {
+        // Property may not exist or be null
+    }
+    // userInfo is a dictionary - basic parsing
+    let userInfo;
+    try {
+        const userInfoDict = nsError.userInfo();
+        if (userInfoDict) {
+            // For now, just get the description
+            // Full dictionary parsing would require NSDictionary wrapper
+            userInfo = {
+                description: userInfoDict.description().UTF8String(),
+            };
+        }
+    }
+    catch (e) {
+        // userInfo may not be accessible
+    }
+    return {
+        domain,
+        code,
+        localizedDescription,
+        ...(localizedFailureReason && { localizedFailureReason }),
+        ...(localizedRecoverySuggestion && { localizedRecoverySuggestion }),
+        ...(userInfo && { userInfo }),
+    };
+}
+/**
+ * Convert an NSError to a JavaScript Error object
+ * @param error The NSError object
+ * @returns A JavaScript Error with NSError details
+ */
+export function nsErrorToJSError(error) {
+    const parsed = parseNSError(error);
+    const jsError = new Error(parsed.localizedDescription);
+    jsError.name = `${parsed.domain} (${parsed.code})`;
+    jsError.nsError = parsed;
+    return jsError;
+}

package/dist/objc/foundation/nsstring.js

@@ -0,0 +1,11 @@
+import { Foundation } from "./index.js";
+export const NSString = Foundation.NSString;
+// Helper Functions
+/**
+ * Create NSString from a JavaScript string
+ * @param str The string object
+ * @returns An NSString object
+ */
+export function NSStringFromString(str) {
+    return NSString.stringWithUTF8String$(str);
+}

package/dist/objc/foundation/nsvalue.js

@@ -0,0 +1,2 @@
+import { Foundation } from ".";
+export const NSValue = Foundation.NSValue;

package/dist/objc/foundation/nsview.js

@@ -0,0 +1,2 @@
+import { Foundation } from "./index.js";
+export const NSView = Foundation.NSView;

package/dist/objc/foundation/nswindow.js

@@ -0,0 +1,2 @@
+import { Foundation } from "./index.js";
+export const NSWindow = Foundation.NSWindow;

package/dist/objc/foundation.js

@@ -0,0 +1,28 @@
+import { NobjcLibrary, NobjcObject } from "@iamevan/nobjc";
+import { NobjcObjectWrapper } from "./helpers";
+// Load the Foundation framework
+export const foundation = new NobjcLibrary("/System/Library/Frameworks/Foundation.framework/Foundation");
+// NSString helpers
+const _NSString = foundation["NSString"];
+const _stringWithUTF8String = _NSString["stringWithUTF8String:"];
+export class NSString extends NobjcObjectWrapper {
+    constructor(str) {
+        super(_stringWithUTF8String(str));
+    }
+}
+// NSData helpers
+const _NSData = foundation["NSData"];
+const _dataWithBytesLength = _NSData["dataWithBytes:length:"];
+export class NSData extends NobjcObjectWrapper {
+    constructor(buffer) {
+        super(_dataWithBytesLength(buffer, buffer.length));
+    }
+}
+// NSArray helpers
+const _NSArray = foundation["NSArray"];
+const _arrayWithObject = _NSArray["arrayWithObject:"];
+export class NSArray extends NobjcObjectWrapper {
+    constructor(obj) {
+        super(_arrayWithObject(obj));
+    }
+}

package/dist/objc/helpers.js

@@ -0,0 +1,31 @@
+export class NobjcInstanceWrapper {
+    _instance;
+    constructor(instance) {
+        this._instance = instance;
+    }
+    get instance() {
+        return this._instance;
+    }
+}
+/**
+ * Helper to allocate and initialize an Objective-C object with a single argument initializer
+ * @param cls The Objective-C class
+ * @param initMethod The initializer method name (e.g., "initWithRelyingPartyIdentifier:")
+ * @param arg The argument to pass to the initializer
+ * @returns The initialized instance
+ */
+export function allocInit(cls, initMethod, arg) {
+    const instance = cls["alloc"]();
+    const initializer = instance[initMethod];
+    return initializer(arg);
+}
+/**
+ * Helper to allocate and initialize an Objective-C object with no arguments
+ * @param cls The Objective-C class
+ * @returns The initialized instance
+ */
+export function allocInitPlain(cls) {
+    const instance = cls["alloc"]();
+    const initializer = instance["init"];
+    return initializer();
+}

package/dist/window.js

@@ -0,0 +1,57 @@
+import { NobjcLibrary, NobjcProtocol } from "objc-js";
+import { allocInitPlain } from "./objc/helpers.js";
+import { NSStringFromString } from "./objc/foundation/nsstring.js";
+const AppKit = new NobjcLibrary("/System/Library/Frameworks/AppKit.framework/AppKit");
+const Foundation = new NobjcLibrary("/System/Library/Frameworks/Foundation.framework/Foundation");
+function createEmptyWindow() {
+    const NSApp = AppKit.NSApplication.sharedApplication();
+    const window = allocInitPlain(AppKit.NSWindow);
+    const styleMask = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3); // titled, closable, miniaturizable, resizable
+    // Make the app active and show the window.
+    window.setStyleMask$(styleMask);
+    window.setFrameFromString$(NSStringFromString("{{100, 100}, {800, 600}}"));
+    NSApp.setActivationPolicy$(0);
+    NSApp.finishLaunching();
+    NSApp.activateIgnoringOtherApps$(true);
+    window.setIsVisible$(true);
+    window.makeKeyWindow();
+    window.orderFrontRegardless();
+    const delegate = NobjcProtocol.implement("NSWindowDelegate", {
+        windowShouldClose$: () => {
+            NSApp.terminate$(NSApp);
+            return true;
+        },
+        windowWillClose$: () => {
+            NSApp.terminate$(NSApp);
+        },
+    });
+    window.setDelegate$(delegate);
+    const shutdown = () => {
+        try {
+            window.close();
+        }
+        finally {
+            NSApp.stop$(NSApp);
+            NSApp.terminate$(NSApp);
+        }
+    };
+    const handleSignal = () => shutdown();
+    process.once("exit", shutdown);
+    process.once("SIGINT", handleSignal);
+    process.once("SIGTERM", handleSignal);
+    process.once("SIGQUIT", handleSignal);
+    // Pump the AppKit run loop for a short tick to keep JS responsive.
+    const runLoop = Foundation.NSRunLoop.currentRunLoop();
+    const pump = () => {
+        const untilDate = Foundation.NSDate.dateWithTimeIntervalSinceNow$(0.01);
+        runLoop.runUntilDate$(untilDate);
+    };
+    const pumpId = setInterval(pump, 10);
+    process.once("exit", () => clearInterval(pumpId));
+    return window;
+}
+function getNativeWindowHandle(window) {
+    // Electron expects an NSView* on macOS; contentView returns that NSView.
+    return window.contentView();
+}
+export { createEmptyWindow, getNativeWindowHandle };

package/package.json

@@ -1,53 +1,27 @@
 {
   "name": "electron-webauthn",
-  "version": "0.0.5",
+  "version": "0.0.6",
+  "repository": "https://github.com/iamEvanYT/electron-webauthn",
+  "description": "Add support for WebAuthn for Electron.",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "napi": {
-    "name": "electron-webauthn",
-    "triples": {
-      "additional": [
-        "aarch64-apple-darwin",
-        "aarch64-pc-windows-msvc"
-      ]
+  "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
     }
   },
-  "license": "MIT",
   "files": [
-    "dist",
-    "index.d.ts",
-    "index.js"
+    "dist/"
   ],
+  "type": "module",
   "devDependencies": {
-    "@napi-rs/cli": "^2.18.4",
-    "ava": "^6.0.1",
-    "typescript": "^5.8.3"
+    "@types/bun": "latest"
   },
-  "ava": {
-    "timeout": "3m"
+  "peerDependencies": {
+    "typescript": "^5"
   },
-  "engines": {
-    "node": ">= 10"
-  },
-  "scripts": {
-    "artifacts": "napi artifacts",
-    "build": "yarn run build:ts && yarn run build:rust",
-    "build:ts": "tsc",
-    "build:rust": "napi build --platform --release",
-    "build:debug": "napi build --platform",
-    "prepublishOnly": "napi prepublish -t npm",
-    "test": "ava",
-    "universal": "napi universal",
-    "version": "napi version"
-  },
-  "packageManager": "yarn@4.9.2",
-  "repository": "https://github.com/iamEvanYT/electron-webauthn.git",
-  "description": "Add support for WebAuthn in Electron.",
-  "optionalDependencies": {
-    "electron-webauthn-win32-x64-msvc": "0.0.5",
-    "electron-webauthn-darwin-x64": "0.0.5",
-    "electron-webauthn-linux-x64-gnu": "0.0.5",
-    "electron-webauthn-darwin-arm64": "0.0.5",
-    "electron-webauthn-win32-arm64-msvc": "0.0.5"
+  "dependencies": {
+    "objc-js": "^0.0.8"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Evan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-import { create, get } from "../index";
-export declare const webauthn: {
-    create: typeof create;
-    get: typeof get;
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEvC,eAAO,MAAM,QAAQ;;;CAGpB,CAAC"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":";;;AAAA,oCAAuC;AAE1B,QAAA,QAAQ,GAAG;IACtB,MAAM,EAAN,cAAM;IACN,GAAG,EAAH,WAAG;CACJ,CAAC"}

package/index.d.ts

@@ -1,68 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-
-/* auto-generated by NAPI-RS */
-
-export interface PublicKeyCredentialRpEntity {
-  id?: string | undefined
-  name: string
-}
-export interface PublicKeyCredentialUserEntity {
-  id: Buffer
-  name: string
-  displayName: string
-}
-export interface PublicKeyCredentialParameters {
-  type: string
-  alg: number
-}
-export interface AuthenticatorSelectionCriteria {
-  authenticatorAttachment?: string | undefined
-  requireResidentKey?: boolean | undefined
-  residentKey?: string | undefined
-  userVerification?: string | undefined
-}
-export interface PublicKeyCredentialDescriptor {
-  type: string
-  id: Buffer
-  transports?: Array<string> | undefined
-}
-export interface PublicKeyCredentialCreationOptions {
-  rp: PublicKeyCredentialRpEntity
-  user: PublicKeyCredentialUserEntity
-  challenge: Buffer
-  pubKeyCredParams: Array<PublicKeyCredentialParameters>
-  timeout?: number | undefined
-  excludeCredentials?: Array<PublicKeyCredentialDescriptor> | undefined
-  authenticatorSelection?: AuthenticatorSelectionCriteria | undefined
-  attestation?: string | undefined
-}
-export interface PublicKeyCredentialRequestOptions {
-  challenge: Buffer
-  timeout?: number | undefined
-  rpId?: string | undefined
-  allowCredentials?: Array<PublicKeyCredentialDescriptor> | undefined
-  userVerification?: string | undefined
-}
-export interface AuthenticatorAttestationResponse {
-  clientDataJson: Buffer
-  attestationObject: Buffer
-  transports: Array<string>
-}
-export interface AuthenticatorAssertionResponse {
-  clientDataJson: Buffer
-  authenticatorData: Buffer
-  signature: Buffer
-  userHandle?: Buffer | undefined
-}
-export interface PublicKeyCredential {
-  id: string
-  rawId: Buffer
-  response: AuthenticatorAttestationResponse | AuthenticatorAssertionResponse
-  authenticatorAttachment?: string | undefined
-  type: string
-}
-/** Create a new WebAuthn credential */
-export declare function create(options: PublicKeyCredentialCreationOptions): PublicKeyCredential
-/** Get/authenticate with an existing WebAuthn credential */
-export declare function get(options: PublicKeyCredentialRequestOptions): PublicKeyCredential