electron-webauthn 0.0.2 → 0.0.6

package/README.md

@@ -1,266 +1,15 @@
-# electron-webauthn
+# electron-webauthn-test
 
-A high-performance, cross-platform WebAuthn/Passkey implementation for Electron applications, built with Rust and native platform APIs.
-
-## Overview
-
-This library provides seamless WebAuthn (Web Authentication) and Passkey support for Electron applications across multiple platforms. It leverages native platform authenticators including Touch ID, Face ID, Windows Hello, and security keys to deliver a secure and user-friendly authentication experience.
-
-### Key Features
-
-- **Native Platform Integration**: Uses platform-specific APIs for optimal performance and security
-- **Cross-Platform Support**: Works on macOS, Windows, and Linux
-- **WebAuthn Level 2 Compliance**: Full support for the latest WebAuthn specifications
-- **Biometric Authentication**: Touch ID, Face ID, Windows Hello, and Apple Watch support
-- **Secure Enclave Integration**: Hardware-backed key storage on supported platforms
-- **TypeScript Support**: Complete type definitions included
-
-## Requirements
-
-### macOS
-
-- **macOS 13+ (Ventura or later)** - Required for ASAuthorization framework
-- Touch ID, Face ID, or Apple Watch for biometric authentication
-- Valid code signing certificate for production use
-
-### Windows
-
-- **Windows 10 version 1903+ or Windows 11**
-- Windows Hello capable device (fingerprint, face recognition, or PIN)
-
-### Linux
-
-- Modern Linux distribution with WebAuthn support
-- Compatible authenticator device
-
-## Installation
+To install dependencies:
 
 ```bash
-npm install electron-webauthn
-# or
-yarn add electron-webauthn
+bun install
 ```
 
-## Usage
-
-### Basic Registration (Creating a Credential)
-
-```typescript
-import { createCredential } from "electron-webauthn";
-
-const options = {
-  rp: {
-    id: "example.com",
-    name: "Example Corp",
-  },
-  user: {
-    id: new Uint8Array([1, 2, 3, 4]),
-    name: "user@example.com",
-    displayName: "John Doe",
-  },
-  challenge: new Uint8Array(32), // Generate random 32 bytes
-  pubKeyCredParams: [
-    { type: "public-key", alg: -7 }, // ES256
-    { type: "public-key", alg: -257 }, // RS256
-  ],
-  authenticatorSelection: {
-    authenticatorAttachment: "platform",
-    userVerification: "required",
-  },
-};
-
-try {
-  const credential = await createCredential(options);
-  console.log("Registration successful:", credential);
-} catch (error) {
-  console.error("Registration failed:", error);
-}
-```
-
-### Basic Authentication (Getting a Credential)
-
-```typescript
-import { getCredential } from "electron-webauthn";
-
-const options = {
-  rpId: "example.com",
-  challenge: new Uint8Array(32), // Generate random 32 bytes
-  allowCredentials: [
-    {
-      type: "public-key",
-      id: credentialId, // From previous registration
-    },
-  ],
-  userVerification: "required",
-};
-
-try {
-  const assertion = await getCredential(options);
-  console.log("Authentication successful:", assertion);
-} catch (error) {
-  console.error("Authentication failed:", error);
-}
-```
-
-## Platform Support
-
-| Platform | Architecture  | Status | Notes                          |
-| -------- | ------------- | ------ | ------------------------------ |
-| macOS    | arm64         | ✅     | Native ASAuthorization support |
-| macOS    | x64           | ✅     | Native ASAuthorization support |
-| macOS    | universal     | ✅     | Universal binary               |
-| Windows  | x64           | ✅     | Windows Hello integration      |
-| Windows  | arm64         | ✅     | Windows Hello integration      |
-| Windows  | ia32          | ✅     | Windows Hello integration      |
-| Linux    | x64 (GNU)     | ✅     | Generic WebAuthn support       |
-| Linux    | x64 (musl)    | ✅     | Alpine Linux compatible        |
-| Linux    | arm64 (GNU)   | ✅     | ARM64 Linux support            |
-| Linux    | arm64 (musl)  | ✅     | ARM64 Alpine support           |
-| Linux    | riscv64 (GNU) | ✅     | RISC-V architecture            |
-
-## macOS Entitlements
-
-For macOS applications, you need to include the following entitlements in your `entitlements.plist` file:
-
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <!-- Required for WebAuthn/Passkey support -->
-    <key>com.apple.developer.authentication-services.autofill-credential-provider</key>
-    <true/>
-
-    <!-- Required for platform authenticator access -->
-    <key>com.apple.developer.web-browser</key>
-    <true/>
-
-    <!-- Required for Touch ID/Face ID/Apple Watch access -->
-    <key>com.apple.security.device.biometry</key>
-    <true/>
-
-    <!-- Required for keychain access -->
-    <key>keychain-access-groups</key>
-    <array>
-        <string>$(AppIdentifierPrefix)com.yourcompany.yourapp</string>
-    </array>
-
-    <!-- Optional: For network requests to verify credentials -->
-    <key>com.apple.security.network.client</key>
-    <true/>
-</dict>
-</plist>
-```
-
-### Electron Builder Configuration
-
-If using `electron-builder`, add the entitlements to your `package.json`:
-
-```json
-{
-  "build": {
-    "mac": {
-      "entitlements": "build/entitlements.mac.plist",
-      "entitlementsInherit": "build/entitlements.mac.plist",
-      "hardenedRuntime": true
-    }
-  }
-}
-```
-
-## Development
-
-### Prerequisites
-
-- Node.js 16+
-- Rust 1.70+
-- Platform-specific build tools:
-  - **macOS**: Xcode Command Line Tools
-  - **Windows**: Visual Studio Build Tools
-  - **Linux**: build-essential
-
-### Building from Source
+To run:
 
 ```bash
-# Clone the repository
-git clone https://github.com/your-org/electron-webauthn.git
-cd electron-webauthn
-
-# Install dependencies
-npm install
-
-# Build the native module
-npm run build
-
-# Run tests
-npm test
-```
-
-### Architecture
-
-This library uses:
-
-- **Rust** for high-performance native implementations
-- **NAPI-RS** for seamless Node.js bindings
-- **Platform-specific APIs**:
-  - macOS: ASAuthorization framework
-  - Windows: Windows Hello APIs
-  - Linux: Generic WebAuthn implementation
-
-## Error Handling
-
-The library provides detailed error messages for common scenarios:
-
-```typescript
-try {
-  const credential = await createCredential(options);
-} catch (error) {
-  switch (error.code) {
-    case "NotSupportedError":
-      console.log("WebAuthn not supported on this platform");
-      break;
-    case "SecurityError":
-      console.log("Security requirements not met");
-      break;
-    case "NotAllowedError":
-      console.log("User cancelled or timeout occurred");
-      break;
-    default:
-      console.log("Unexpected error:", error.message);
-  }
-}
+bun run index.ts
 ```
 
-## Security Considerations
-
-- Always validate challenges on your server
-- Use HTTPS in production environments
-- Implement proper CORS policies
-- Store credentials securely on your backend
-- Regularly update the library for security patches
-
-## Contributing
-
-We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
-
-### Development Setup
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Add tests for new functionality
-5. Submit a pull request
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-## Support
-
-- **Issues**: [GitHub Issues](https://github.com/your-org/electron-webauthn/issues)
-- **Documentation**: [API Documentation](https://docs.your-org.com/electron-webauthn)
-- **Community**: [Discussions](https://github.com/your-org/electron-webauthn/discussions)
-
-## Changelog
-
-See [CHANGELOG.md](CHANGELOG.md) for a detailed history of changes.
+This project was created using `bun init` in bun v1.3.5. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/example.js

@@ -0,0 +1,23 @@
+import { NSData } from "./objc/foundation/nsdata.js";
+import { NSString } from "./objc/foundation/nsstring.js";
+import { NSArray } from "./objc/foundation/nsarray.js";
+const myString = NSString.stringWithUTF8String$("Hello from Objective-C!");
+console.log("Created NSString:", myString);
+const buf = Buffer.from("Hello from Objective-C!");
+const myData = NSData.dataWithBytes$length$(buf, buf.length);
+console.log("Created NSData:", myData);
+// Test NSArray
+const str1 = NSString.stringWithUTF8String$("First");
+const str2 = NSString.stringWithUTF8String$("Second");
+const str3 = NSString.stringWithUTF8String$("Third");
+// Create array with one object, then add more
+let myArray = NSArray.arrayWithObject$(str1);
+myArray = myArray.arrayByAddingObject$(str2);
+myArray = myArray.arrayByAddingObject$(str3);
+console.log("Created NSArray with count:", myArray.count());
+// Access elements
+for (let i = 0; i < myArray.count(); i++) {
+    const obj = myArray.objectAtIndex$(i);
+    const nsString = obj;
+    console.log(`Array[${i}]:`, nsString.UTF8String());
+}

package/dist/helper.js

@@ -0,0 +1,23 @@
+import { NobjcLibrary, NobjcObject } from "@iamevan/nobjc";
+// Load the Foundation framework
+export const foundation = new NobjcLibrary("/System/Library/Frameworks/Foundation.framework/Foundation");
+// Load the AuthenticationServices framework
+export const authServices = new NobjcLibrary("/System/Library/Frameworks/AuthenticationServices.framework/AuthenticationServices");
+// NSString helpers
+const NSString = foundation["NSString"];
+const _stringWithUTF8String = NSString["stringWithUTF8String:"];
+export function createNSString(str) {
+    return _stringWithUTF8String(str);
+}
+// NSData helpers
+const NSData = foundation["NSData"];
+const _dataWithBytesLength = NSData["dataWithBytes:length:"];
+export function createNSData(buffer) {
+    return _dataWithBytesLength(buffer, buffer.length);
+}
+// NSArray helpers
+const NSArray = foundation["NSArray"];
+const _arrayWithObject = NSArray["arrayWithObject:"];
+export function createNSArray(obj) {
+    return _arrayWithObject(obj);
+}

package/dist/index.js

@@ -1,9 +1,49 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.webauthn = void 0;
-const index_1 = require("../index");
-exports.webauthn = {
-    create: index_1.create,
-    get: index_1.get,
-};
-//# sourceMappingURL=index.js.map
+import { fromPointer, getPointer } from "objc-js";
+import { createAuthorizationControllerDelegate } from "./objc/authentication-services/as-authorization-controller-delegate.js";
+import { createAuthorizationController } from "./objc/authentication-services/as-authorization-controller.js";
+import { createPresentationContextProvider } from "./objc/authentication-services/as-authorization-controller-presentation-context-providing.js";
+import { createPlatformPublicKeyCredentialProvider } from "./objc/authentication-services/as-authorization-platform-public-key-credential-provider.js";
+import { NSArray } from "./objc/foundation/nsarray.js";
+import { NSDataFromBuffer } from "./objc/foundation/nsdata.js";
+import { NSStringFromString } from "./objc/foundation/nsstring.js";
+// const window = createEmptyWindow();
+// const nsView = getNativeWindowHandle(window);
+// const nsViewPointer = getPointer(nsView);
+function getCredential(rpid, challenge, nativeWindowHandle) {
+    const NS_rpID = NSStringFromString(rpid);
+    // let challenge: Data // Obtain this from the server.
+    const NS_challenge = NSDataFromBuffer(challenge);
+    // let platformProvider = ASAuthorizationPlatformPublicKeyCredentialProvider(relyingPartyIdentifier: "example.com")
+    const platformProvider = createPlatformPublicKeyCredentialProvider(NS_rpID);
+    // let platformKeyRequest = platformProvider.createCredentialAssertionRequest(challenge: challenge)
+    const platformKeyRequest = platformProvider.createCredentialAssertionRequestWithChallenge$(NS_challenge);
+    // let authController = ASAuthorizationController(authorizationRequests: [platformKeyRequest])
+    const requestsArray = NSArray.arrayWithObject$(platformKeyRequest);
+    const authController = createAuthorizationController(requestsArray);
+    // authController.delegate = self
+    const delegate = createAuthorizationControllerDelegate({
+        didCompleteWithAuthorization: (controller, authorization) => {
+            console.log("Authorization succeeded:", authorization);
+        },
+        didCompleteWithError: (controller, error) => {
+            // Parse the NSError into a readable format
+            const parsedError = error;
+            console.error("Authorization failed:", parsedError.localizedDescription().UTF8String());
+        },
+    });
+    authController.setDelegate$(delegate);
+    // authController.presentationContextProvider = self
+    const presentationContextProvider = createPresentationContextProvider({
+        presentationAnchorForAuthorizationController: (controller) => {
+            // Return the NSWindow to present the authorization UI in
+            const nsView = fromPointer(nativeWindowHandle);
+            const nsWindow = nsView.window();
+            return nsWindow;
+        },
+    });
+    authController.setPresentationContextProvider$(presentationContextProvider);
+    // authController.performRequests()
+    authController.performRequests();
+    return authController;
+}
+export { getCredential };

package/dist/objc/auth-services.js

@@ -0,0 +1,28 @@
+import { NobjcLibrary, NobjcObject } from "@iamevan/nobjc";
+import { allocInit, NobjcInstanceWrapper } from "./helpers.js";
+// Load the AuthenticationServices framework
+export const authServices = new NobjcLibrary("/System/Library/Frameworks/AuthenticationServices.framework/AuthenticationServices");
+// Wrapper for ASAuthorizationPlatformPublicKeyCredentialProvider
+const _ASAuthorizationPlatformPublicKeyCredentialProvider = authServices["ASAuthorizationPlatformPublicKeyCredentialProvider"];
+export class ASAuthorizationPlatformPublicKeyCredentialProvider extends NobjcInstanceWrapper {
+    constructor(relyingPartyIdentifier) {
+        const instance = allocInit(_ASAuthorizationPlatformPublicKeyCredentialProvider, "initWithRelyingPartyIdentifier:", relyingPartyIdentifier);
+        super(instance);
+    }
+    createCredentialAssertionRequest(challenge) {
+        const method = this.instance["createCredentialAssertionRequestWithChallenge:"];
+        return method(challenge);
+    }
+}
+// Wrapper for ASAuthorizationController
+const _ASAuthorizationController = authServices["ASAuthorizationController"];
+export class ASAuthorizationController extends NobjcInstanceWrapper {
+    constructor(authorizationRequests) {
+        const instance = allocInit(_ASAuthorizationController, "initWithAuthorizationRequests:", authorizationRequests);
+        super(instance);
+    }
+    performRequests() {
+        const method = this.instance["performRequests"];
+        method();
+    }
+}

package/dist/objc/authentication-services/as-authorization-controller-delegate.js

@@ -0,0 +1,40 @@
+import { NobjcObject, NobjcProtocol } from "objc-js";
+/**
+ * Create an ASAuthorizationControllerDelegate instance
+ *
+ * This creates an Objective-C object that implements the ASAuthorizationControllerDelegate
+ * protocol using the objc-js protocol implementation API.
+ *
+ * @param callbacks Object containing callback functions for delegate methods
+ * @returns A NobjcObject that can be set as the delegate of an ASAuthorizationController
+ *
+ * @example
+ * ```typescript
+ * const delegate = createAuthorizationControllerDelegate({
+ *   didCompleteWithAuthorization: (controller, authorization) => {
+ *     console.log("Authorization succeeded!");
+ *     const credential = authorization.credential();
+ *     // Process the credential
+ *   },
+ *   didCompleteWithError: (controller, error) => {
+ *     console.error("Authorization failed:", error.localizedDescription());
+ *   }
+ * });
+ *
+ * authController.setDelegate$(delegate);
+ * authController.performRequests();
+ * ```
+ */
+export function createAuthorizationControllerDelegate(callbacks) {
+    const methodImplementations = {};
+    // Map the callbacks to Objective-C method names using $ notation
+    if (callbacks.didCompleteWithAuthorization) {
+        methodImplementations["authorizationController$didCompleteWithAuthorization$"] = callbacks.didCompleteWithAuthorization;
+    }
+    if (callbacks.didCompleteWithError) {
+        methodImplementations["authorizationController$didCompleteWithError$"] =
+            callbacks.didCompleteWithError;
+    }
+    // Create and return the protocol implementation
+    return NobjcProtocol.implement("ASAuthorizationControllerDelegate", methodImplementations);
+}

package/dist/objc/authentication-services/as-authorization-controller-presentation-context-providing.js

@@ -0,0 +1,31 @@
+import { NobjcObject, NobjcProtocol } from "objc-js";
+/**
+ * Create an ASAuthorizationControllerPresentationContextProviding instance
+ *
+ * This creates an Objective-C object that implements the ASAuthorizationControllerPresentationContextProviding
+ * protocol using the objc-js protocol implementation API.
+ *
+ * @param callbacks Object containing callback functions for protocol methods
+ * @returns A NobjcObject that can be set as the presentationContextProvider of an ASAuthorizationController
+ *
+ * @example
+ * ```typescript
+ * const presentationContextProvider = createPresentationContextProvider({
+ *   presentationAnchorForAuthorizationController: (controller) => {
+ *     // Return the NSWindow to present the authorization UI in
+ *     return myNSWindow;
+ *   }
+ * });
+ *
+ * authController.setPresentationContextProvider$(presentationContextProvider);
+ * authController.performRequests();
+ * ```
+ */
+export function createPresentationContextProvider(callbacks) {
+    const methodImplementations = {};
+    // Map the callback to Objective-C method name using $ notation
+    methodImplementations["presentationAnchorForAuthorizationController$"] =
+        callbacks.presentationAnchorForAuthorizationController;
+    // Create and return the protocol implementation
+    return NobjcProtocol.implement("ASAuthorizationControllerPresentationContextProviding", methodImplementations);
+}

package/dist/objc/authentication-services/as-authorization-controller.js

@@ -0,0 +1,12 @@
+import { AuthenticationServices } from "./index.js";
+export const ASAuthorizationController = AuthenticationServices.ASAuthorizationController;
+// Helper Functions
+/**
+ * Create an ASAuthorizationController instance
+ * @param authorizationRequests An NSArray of authorization requests
+ * @returns An initialized controller instance
+ */
+export function createAuthorizationController(authorizationRequests) {
+    const instance = ASAuthorizationController.alloc();
+    return instance.initWithAuthorizationRequests$(authorizationRequests);
+}

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

@@ -0,0 +1,12 @@
+import { AuthenticationServices } from "./index.js";
+export const ASAuthorizationPlatformPublicKeyCredentialProvider = AuthenticationServices.ASAuthorizationPlatformPublicKeyCredentialProvider;
+// Helper Functions
+/**
+ * Create an ASAuthorizationPlatformPublicKeyCredentialProvider instance
+ * @param relyingPartyIdentifier The relying party identifier (domain)
+ * @returns An initialized provider instance
+ */
+export function createPlatformPublicKeyCredentialProvider(relyingPartyIdentifier) {
+    const instance = ASAuthorizationPlatformPublicKeyCredentialProvider.alloc();
+    return instance.initWithRelyingPartyIdentifier$(relyingPartyIdentifier);
+}

package/dist/objc/authentication-services/index.js

@@ -0,0 +1,3 @@
+import { NobjcLibrary } from "objc-js";
+// Load the framework
+export const AuthenticationServices = new NobjcLibrary("/System/Library/Frameworks/AuthenticationServices.framework/AuthenticationServices");

package/dist/objc/foundation/helpers.js

@@ -0,0 +1,142 @@
+import { NSArray, NSData, NSString } from "./main";
+/**
+ * Foundation Framework Helpers
+ *
+ * This module provides convenient helper functions for working with
+ * Foundation framework objects in JavaScript/TypeScript.
+ *
+ * Key features:
+ * - NSString: String conversion helpers
+ * - NSData: Data conversion between Objective-C and JavaScript
+ * - NSArray: Array creation and manipulation
+ */
+/**
+ * NSData to Buffer Conversion Methods
+ *
+ * Two methods are provided for converting NSData to JavaScript Buffers:
+ *
+ * 1. bufferFromNSData (base64): Uses base64 as an intermediate format.
+ *    - Most reliable and compatible
+ *    - Recommended for general use
+ *    - Slight overhead due to base64 encoding/decoding
+ *
+ * 2. bufferFromNSDataDirect (direct): Uses getBytes:length: for direct memory copy.
+ *    - More efficient for large data
+ *    - Direct memory access
+ *    - May have compatibility issues with some nobjc versions
+ */
+/**
+ * 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);
+}
+// NSArray helpers
+export function NSArrayFromObjects(objects) {
+    let array = NSArray.array();
+    for (const obj of objects) {
+        array = array.arrayByAddingObject$(obj);
+    }
+    return array;
+}

package/dist/objc/foundation/index.js

@@ -0,0 +1,3 @@
+import { NobjcLibrary } from "objc-js";
+// Load the framework
+export const Foundation = new NobjcLibrary("/System/Library/Frameworks/Foundation.framework/Foundation");

package/dist/objc/foundation/main.js

@@ -0,0 +1,4 @@
+import { NobjcLibrary, NobjcObject } from "@iamevan/nobjc";
+// Load the Foundation framework
+export const Foundation = new NobjcLibrary("/System/Library/Frameworks/Foundation.framework/Foundation");
+export const NSArray = Foundation.NSArray;