@onekeyfe/react-native-sni-connect 1.0.0

package/ios/SniConnectClient.swift

@@ -0,0 +1,490 @@
+import Foundation
+import EMASCurl
+
+/// Core HTTPS client that enforces IP direct connection with SNI.
+final class SniConnectClient {
+
+  // Logging callback
+  var onLog: ((String, String) -> Void)?
+
+  // Active requests tracking for cancellation support
+  private var activeTasks: [String: Task<Response, Error>] = [:]
+  private let tasksQueue = DispatchQueue(label: "com.onekey.sni.connect.tasks", attributes: .concurrent)
+
+  init() {
+    // Register for memory warnings to clean cache
+    NotificationCenter.default.addObserver(
+      forName: UIApplication.didReceiveMemoryWarningNotification,
+      object: nil,
+      queue: .main
+    ) { [weak self] _ in
+      self?.onLog?("warning", "Memory warning received, cleaning DNS cache")
+      DNSResolver.cleanExpiredEntries()
+    }
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+
+  struct RequestConfig {
+    let requestId: String? // Optional request ID for cancellation
+    let ip: String
+    let hostname: String
+    let method: String
+    let path: String
+    let headers: [String: String]
+    let body: String?
+    let timeout: TimeInterval
+
+    // Advanced timeout configurations
+    let connectTimeout: TimeInterval? // Connection establishment timeout
+    let totalTimeout: TimeInterval? // Total request timeout (overrides `timeout`)
+
+    var effectiveConnectTimeout: TimeInterval {
+      connectTimeout ?? min(timeout / 3, 10.0)
+    }
+
+    var effectiveTotalTimeout: TimeInterval {
+      totalTimeout ?? timeout
+    }
+  }
+
+  struct Response {
+    let data: Any
+    let status: Int
+    let statusText: String
+    let headers: [String: String] // Single-value headers (backward compatible)
+    let multiValueHeaders: [String: [String]] // Multi-value headers (e.g., Set-Cookie)
+  }
+
+  enum SniConnectError: Error {
+    case invalidURL
+    case invalidConfig(String)
+    case dnsResolutionFailed(String)
+    case tlsHandshakeFailed(String)
+    case certificateValidationFailed(String)
+    case connectionTimeout
+    case connectionRefused
+    case networkUnreachable
+    case requestTimeout
+    case httpError(code: Int, message: String)
+    case cancelled
+    case unknown(Error)
+
+    var code: String {
+      switch self {
+      case .invalidURL: return "SNI_INVALID_URL"
+      case .invalidConfig: return "SNI_INVALID_CONFIG"
+      case .dnsResolutionFailed: return "SNI_DNS_FAILED"
+      case .tlsHandshakeFailed: return "SNI_TLS_FAILED"
+      case .certificateValidationFailed: return "SNI_CERT_FAILED"
+      case .connectionTimeout: return "SNI_TIMEOUT"
+      case .connectionRefused: return "SNI_CONNECTION_REFUSED"
+      case .networkUnreachable: return "SNI_NETWORK_UNREACHABLE"
+      case .requestTimeout: return "SNI_REQUEST_TIMEOUT"
+      case .httpError: return "SNI_HTTP_ERROR"
+      case .cancelled: return "SNI_CANCELLED"
+      case .unknown: return "SNI_UNKNOWN_ERROR"
+      }
+    }
+
+    var message: String {
+      switch self {
+      case .invalidURL:
+        return "Invalid URL format"
+      case .invalidConfig(let details):
+        return "Invalid configuration: \(details)"
+      case .dnsResolutionFailed(let domain):
+        return "DNS resolution failed for domain: \(domain)"
+      case .tlsHandshakeFailed(let details):
+        return "TLS handshake failed: \(details)"
+      case .certificateValidationFailed(let details):
+        return "Certificate validation failed: \(details)"
+      case .connectionTimeout:
+        return "Connection timeout"
+      case .connectionRefused:
+        return "Connection refused by server"
+      case .networkUnreachable:
+        return "Network unreachable"
+      case .requestTimeout:
+        return "Request timeout"
+      case .httpError(let code, let message):
+        return "HTTP error \(code): \(message)"
+      case .cancelled:
+        return "Request cancelled"
+      case .unknown(let error):
+        return "Unknown error: \(error.localizedDescription)"
+      }
+    }
+
+    /// Convert NSError to SniConnectError with detailed classification
+    static func from(_ error: Error) -> SniConnectError {
+      let nsError = error as NSError
+
+      // Check for URL-related errors
+      if nsError.domain == NSURLErrorDomain {
+        switch nsError.code {
+        case NSURLErrorTimedOut:
+          return .requestTimeout
+        case NSURLErrorCannotConnectToHost:
+          return .connectionRefused
+        case NSURLErrorNotConnectedToInternet, NSURLErrorNetworkConnectionLost:
+          return .networkUnreachable
+        case NSURLErrorSecureConnectionFailed:
+          return .tlsHandshakeFailed(nsError.localizedDescription)
+        case NSURLErrorServerCertificateUntrusted, NSURLErrorServerCertificateHasBadDate,
+             NSURLErrorServerCertificateHasUnknownRoot, NSURLErrorServerCertificateNotYetValid:
+          return .certificateValidationFailed(nsError.localizedDescription)
+        case NSURLErrorCannotFindHost, NSURLErrorDNSLookupFailed:
+          return .dnsResolutionFailed(nsError.localizedDescription)
+        case NSURLErrorCancelled:
+          return .cancelled
+        default:
+          return .unknown(error)
+        }
+      }
+
+      return .unknown(error)
+    }
+  }
+
+  private static let urlSession: URLSession = {
+    let configuration = URLSessionConfiguration.default
+    configuration.requestCachePolicy = .reloadIgnoringLocalCacheData
+    configuration.urlCache = nil
+    configuration.httpCookieStorage = nil
+    configuration.httpShouldSetCookies = false
+    configuration.shouldUseExtendedBackgroundIdleMode = false
+
+    let curlConfig = EMASCurlConfiguration.default()
+    curlConfig.httpVersion = .HTTP2
+    curlConfig.connectTimeoutInterval = 2.5
+    curlConfig.enableBuiltInGzip = true
+    curlConfig.enableBuiltInRedirection = true
+    curlConfig.cacheEnabled = false
+
+    // Enable full certificate validation for security
+    // The certificate will be validated against the SNI hostname, not the IP
+    curlConfig.certificateValidationEnabled = true
+    curlConfig.domainNameVerificationEnabled = true
+    curlConfig.dnsResolver = DNSResolver.self
+
+    EMASCurlProtocol.install(into: configuration, with: curlConfig)
+    return URLSession(configuration: configuration)
+  }()
+
+  @objc private final class DNSResolver: NSObject, EMASCurlProtocolDNSResolver {
+    private static let queue = DispatchQueue(label: "com.onekey.sni.connect.dns", attributes: .concurrent)
+    private static let cache = DNSCache()
+
+    /// LRU cache for DNS mappings with size limit and TTL support
+    private class DNSCache {
+      private struct CacheEntry {
+        let ip: String
+        let timestamp: TimeInterval
+      }
+
+      private var storage: [String: CacheEntry] = [:]
+      private var accessOrder: [String] = []
+
+      // Maximum cache entries (100 as specified in requirements)
+      private let maxSize = 100
+      // TTL in seconds (5 minutes default)
+      private let ttl: TimeInterval = 300
+
+      func get(_ domain: String) -> String? {
+        let key = domain.lowercased()
+        guard let entry = storage[key] else { return nil }
+
+        // Check if entry has expired
+        let now = Date().timeIntervalSince1970
+        if now - entry.timestamp > ttl {
+          remove(key)
+          return nil
+        }
+
+        // Update access order (LRU)
+        if let index = accessOrder.firstIndex(of: key) {
+          accessOrder.remove(at: index)
+        }
+        accessOrder.append(key)
+
+        return entry.ip
+      }
+
+      func set(_ ip: String, for domain: String) {
+        let key = domain.lowercased()
+
+        // Evict oldest entry if cache is full
+        if storage.count >= maxSize && storage[key] == nil {
+          if let oldest = accessOrder.first {
+            storage.removeValue(forKey: oldest)
+            accessOrder.removeFirst()
+          }
+        }
+
+        // Add or update entry
+        let entry = CacheEntry(ip: ip, timestamp: Date().timeIntervalSince1970)
+        storage[key] = entry
+
+        // Update access order
+        if let index = accessOrder.firstIndex(of: key) {
+          accessOrder.remove(at: index)
+        }
+        accessOrder.append(key)
+      }
+
+      func remove(_ domain: String) {
+        let key = domain.lowercased()
+        storage.removeValue(forKey: key)
+        if let index = accessOrder.firstIndex(of: key) {
+          accessOrder.remove(at: index)
+        }
+      }
+
+      func clear() {
+        storage.removeAll()
+        accessOrder.removeAll()
+      }
+
+      func cleanExpired() {
+        let now = Date().timeIntervalSince1970
+        let expiredKeys = storage.filter { now - $0.value.timestamp > ttl }.map { $0.key }
+        for key in expiredKeys {
+          remove(key)
+        }
+      }
+    }
+
+    @objc static func resolveDomain(_ domain: String) -> String? {
+      var result: String?
+      queue.sync {
+        result = cache.get(domain)
+      }
+      return result
+    }
+
+    static func setIP(_ ip: String, for host: String) {
+      queue.sync(flags: .barrier) {
+        cache.set(ip, for: host)
+      }
+    }
+
+    /// Clear all DNS cache entries
+    static func clearCache() {
+      queue.sync(flags: .barrier) {
+        cache.clear()
+      }
+    }
+
+    /// Clean expired DNS cache entries
+    static func cleanExpiredEntries() {
+      queue.sync(flags: .barrier) {
+        cache.cleanExpired()
+      }
+    }
+  }
+
+  /// Clear all DNS cache entries
+  func clearDNSCache() {
+    DNSResolver.clearCache()
+    onLog?("info", "DNS cache cleared")
+  }
+
+  /// Cancel a request by ID
+  func cancelRequest(requestId: String) {
+    tasksQueue.async(flags: .barrier) { [weak self] in
+      guard let task = self?.activeTasks[requestId] else {
+        self?.onLog?("warning", "No active request found with ID: \(requestId)")
+        return
+      }
+      task.cancel()
+      self?.activeTasks.removeValue(forKey: requestId)
+      self?.onLog?("info", "Request cancelled: \(requestId)")
+    }
+  }
+
+  /// Cancel all active requests
+  func cancelAllRequests() {
+    tasksQueue.async(flags: .barrier) { [weak self] in
+      guard let self = self else { return }
+      let count = self.activeTasks.count
+      for (_, task) in self.activeTasks {
+        task.cancel()
+      }
+      self.activeTasks.removeAll()
+      self.onLog?("info", "Cancelled \(count) active requests")
+    }
+  }
+
+  /// Register an active task (synchronous for immediate registration)
+  func registerTask(_ task: Task<Response, Error>, for requestId: String) {
+    tasksQueue.sync(flags: .barrier) { [weak self] in
+      self?.activeTasks[requestId] = task
+      self?.onLog?("info", "Registered request: \(requestId), total active: \(self?.activeTasks.count ?? 0)")
+    }
+  }
+
+  /// Unregister a completed or failed task
+  private func unregisterTask(requestId: String?) {
+    guard let requestId = requestId else { return }
+    tasksQueue.async(flags: .barrier) { [weak self] in
+      self?.activeTasks.removeValue(forKey: requestId)
+      self?.onLog?("info", "Unregistered request: \(requestId)")
+    }
+  }
+
+  func performRequest(config: RequestConfig) async throws -> Response {
+    // Check if task is cancelled
+    try Task.checkCancellation()
+
+    defer {
+      unregisterTask(requestId: config.requestId)
+    }
+
+    DNSResolver.setIP(config.ip, for: config.hostname)
+
+    let url = try Self.buildURL(hostname: config.hostname, path: config.path)
+
+    let mutableRequest = NSMutableURLRequest(url: url)
+    mutableRequest.httpMethod = config.method.uppercased()
+
+    // Convert milliseconds to seconds for timeout values
+    let totalTimeoutSeconds = config.effectiveTotalTimeout / 1000.0
+    let connectTimeoutSeconds = config.effectiveConnectTimeout / 1000.0
+
+    // Set total request timeout
+    mutableRequest.timeoutInterval = totalTimeoutSeconds
+    mutableRequest.cachePolicy = .reloadIgnoringLocalCacheData
+
+    // Explicitly set Host header for SNI
+    mutableRequest.setValue(config.hostname, forHTTPHeaderField: "Host")
+
+    for (key, value) in config.headers {
+      if key.caseInsensitiveCompare("host") == .orderedSame {
+        // Host header is already set above, skip duplicate
+        continue
+      }
+      mutableRequest.setValue(value, forHTTPHeaderField: key)
+    }
+
+    if let bodyString = config.body, let bodyData = bodyString.data(using: .utf8) {
+      mutableRequest.httpBody = bodyData
+    }
+
+    // Configure connection timeout for EMASCurl
+    EMASCurlProtocol.setConnectTimeoutInterval(connectTimeoutSeconds)
+    let request = mutableRequest as URLRequest
+
+    do {
+      let (data, response) = try await Self.urlSession.data(for: request)
+      guard let httpResponse = response as? HTTPURLResponse else {
+        let errorMsg = "Invalid HTTP response type"
+        onLog?("error", errorMsg)
+        throw SniConnectError.invalidConfig(errorMsg)
+      }
+
+      let status = httpResponse.statusCode
+      let parsedData = Self.parseResponseData(data)
+      let (headers, multiValueHeaders) = Self.extractHeaders(from: httpResponse)
+      let statusText = HTTPURLResponse.localizedString(forStatusCode: status)
+
+      // Check for HTTP errors (4xx, 5xx)
+      if status >= 400 {
+        let error = SniConnectError.httpError(code: status, message: statusText)
+        onLog?("error", "HTTP error: \(error.message)")
+        // Still return the response for client to handle
+      }
+
+      return Response(
+        data: parsedData,
+        status: status,
+        statusText: statusText,
+        headers: headers,
+        multiValueHeaders: multiValueHeaders
+      )
+    } catch let error as SniConnectError {
+      onLog?("error", "[\(error.code)] \(error.message)")
+      throw error
+    } catch {
+      // Convert generic errors to specific SniConnectError types
+      let sniError = SniConnectError.from(error)
+      onLog?("error", "[\(sniError.code)] \(sniError.message)")
+      throw sniError
+    }
+  }
+
+  private static func buildURL(hostname: String, path: String) throws -> URL {
+    let trimmedPath = path.trimmingCharacters(in: .whitespacesAndNewlines)
+
+    if let url = URL(string: trimmedPath), url.scheme != nil {
+      return url
+    }
+
+    let normalizedPath: String
+    if trimmedPath.isEmpty {
+      normalizedPath = "/"
+    } else if trimmedPath.hasPrefix("/") {
+      normalizedPath = trimmedPath
+    } else {
+      normalizedPath = "/" + trimmedPath
+    }
+
+    guard let url = URL(string: "https://\(hostname)\(normalizedPath)") else {
+      throw SniConnectError.invalidURL
+    }
+    return url
+  }
+
+  private static func parseResponseData(_ data: Data) -> Any {
+    guard !data.isEmpty else {
+      return [:]
+    }
+
+    if let jsonObject = try? JSONSerialization.jsonObject(with: data, options: []) {
+      return jsonObject
+    }
+
+    if let text = String(data: data, encoding: .utf8) {
+      return text
+    }
+
+    return data.base64EncodedString()
+  }
+
+  /// Extract headers from HTTP response
+  /// Returns both single-value headers (for backward compatibility) and multi-value headers
+  private static func extractHeaders(from response: HTTPURLResponse) -> ([String: String], [String: [String]]) {
+    var singleValueHeaders: [String: String] = [:]
+    var multiValueHeaders: [String: [String]] = [:]
+
+    // Group headers by normalized key (lowercase)
+    var headerGroups: [String: [String]] = [:]
+
+    for (key, value) in response.allHeaderFields {
+      let headerKey = String(describing: key).lowercased()
+      let headerValue = String(describing: value)
+
+      if headerGroups[headerKey] == nil {
+        headerGroups[headerKey] = []
+      }
+      headerGroups[headerKey]?.append(headerValue)
+    }
+
+    // Process grouped headers
+    for (key, values) in headerGroups {
+      // For backward compatibility, single-value headers use the last value
+      singleValueHeaders[key] = values.last
+
+      // Multi-value headers contain all values
+      if values.count > 1 {
+        multiValueHeaders[key] = values
+      } else {
+        multiValueHeaders[key] = values
+      }
+    }
+
+    return (singleValueHeaders, multiValueHeaders)
+  }
+}

package/lib/module/@types/react-native-codegen.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=react-native-codegen.d.js.map

package/lib/module/@types/react-native-codegen.d.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["@types/react-native-codegen.d.ts"],"mappings":"","ignoreList":[]}

package/lib/module/NativeSniConnect.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import { NativeModules, Platform, TurboModuleRegistry } from 'react-native';
+const LINKING_ERROR = `The package '@onekeyfe/react-native-sni-connect' doesn't seem to be linked. Make sure:\n\n` + Platform.select({
+  ios: "- You have run 'pod install'\n",
+  default: ''
+}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go; create a custom dev client instead\n';
+const turboModuleResult = TurboModuleRegistry.get('SniConnect');
+const turboModule = turboModuleResult ?? null;
+const bridgeModule = NativeModules.SniConnect ?? null;
+const nativeModule = turboModule ?? bridgeModule;
+if (nativeModule == null) {
+  throw new Error(LINKING_ERROR);
+}
+const NativeSniConnect = nativeModule;
+export default NativeSniConnect;
+//# sourceMappingURL=NativeSniConnect.js.map

package/lib/module/NativeSniConnect.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeModules","Platform","TurboModuleRegistry","LINKING_ERROR","select","ios","default","turboModuleResult","get","turboModule","bridgeModule","SniConnect","nativeModule","Error","NativeSniConnect"],"sourceRoot":"../../src","sources":["NativeSniConnect.ts"],"mappings":";;AAAA,SACEA,aAAa,EACbC,QAAQ,EACRC,mBAAmB,QAEd,cAAc;AAoCrB,MAAMC,aAAa,GACjB,4FAA4F,GAC5FF,QAAQ,CAACG,MAAM,CAAC;EAAEC,GAAG,EAAE,gCAAgC;EAAEC,OAAO,EAAE;AAAG,CAAC,CAAC,GACvE,sDAAsD,GACtD,mEAAmE;AASrE,MAAMC,iBAAiB,GAAGL,mBAAmB,CAACM,GAAG,CAAO,YAAY,CAAC;AAErE,MAAMC,WAAwB,GAAGF,iBAAiB,IAAI,IAAI;AAE1D,MAAMG,YAAyB,GAC5BV,aAAa,CAACW,UAAU,IAAyB,IAAI;AAExD,MAAMC,YAAY,GAAIH,WAAW,IAAIC,YAAwC;AAE7E,IAAIE,YAAY,IAAI,IAAI,EAAE;EACxB,MAAM,IAAIC,KAAK,CAACV,aAAa,CAAC;AAChC;AAEA,MAAMW,gBAAkC,GAAGF,YAAY;AAEvD,eAAeE,gBAAgB","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import { NativeEventEmitter } from 'react-native';
+import NativeSniConnect from "./NativeSniConnect.js";
+
+// Log entry type definition
+
+// Create event emitter instance
+const eventEmitter = new NativeEventEmitter(NativeSniConnect);
+
+// Simple log subscription function
+export function subscribeToLogs(callback) {
+  const subscription = eventEmitter.addListener('SniConnectLog', log => {
+    // Type assertion since we know the structure
+    callback(log);
+  });
+  return () => subscription.remove();
+}
+export function request(config) {
+  return NativeSniConnect.request(config);
+}
+export function cancelRequest(requestId) {
+  return NativeSniConnect.cancelRequest(requestId);
+}
+export function cancelAllRequests() {
+  return NativeSniConnect.cancelAllRequests();
+}
+export function clearDNSCache() {
+  return NativeSniConnect.clearDNSCache();
+}
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeEventEmitter","NativeSniConnect","eventEmitter","subscribeToLogs","callback","subscription","addListener","log","remove","request","config","cancelRequest","requestId","cancelAllRequests","clearDNSCache"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,kBAAkB,QAAQ,cAAc;AACjD,OAAOC,gBAAgB,MAGhB,uBAAoB;;AAE3B;;AAOA;AACA,MAAMC,YAAY,GAAG,IAAIF,kBAAkB,CAACC,gBAAuB,CAAC;;AAEpE;AACA,OAAO,SAASE,eAAeA,CAACC,QAAiC,EAAc;EAC7E,MAAMC,YAAY,GAAGH,YAAY,CAACI,WAAW,CAAC,eAAe,EAAGC,GAAQ,IAAK;IAC3E;IACAH,QAAQ,CAACG,GAAe,CAAC;EAC3B,CAAC,CAAC;EACF,OAAO,MAAMF,YAAY,CAACG,MAAM,CAAC,CAAC;AACpC;AAEA,OAAO,SAASC,OAAOA,CACrBC,MAAyB,EACI;EAC7B,OAAOT,gBAAgB,CAACQ,OAAO,CAACC,MAAM,CAAC;AACzC;AAEA,OAAO,SAASC,aAAaA,CAC3BC,SAAiB,EACc;EAC/B,OAAOX,gBAAgB,CAACU,aAAa,CAACC,SAAS,CAAC;AAClD;AAEA,OAAO,SAASC,iBAAiBA,CAAA,EAAkC;EACjE,OAAOZ,gBAAgB,CAACY,iBAAiB,CAAC,CAAC;AAC7C;AAEA,OAAO,SAASC,aAAaA,CAAA,EAAkC;EAC7D,OAAOb,gBAAgB,CAACa,aAAa,CAAC,CAAC;AACzC","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/NativeSniConnect.d.ts

@@ -0,0 +1,50 @@
+import { type TurboModule } from 'react-native';
+import type { Double, Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+type HeaderMap = {
+    [key: string]: string;
+};
+export type SniConnectRequest = {
+    requestId?: string;
+    ip: string;
+    hostname: string;
+    method: string;
+    path: string;
+    headers: HeaderMap;
+    body?: string | null;
+    timeout: Double;
+};
+export type SniConnectResponse = {
+    data: string;
+    status: Int32;
+    statusText: string;
+    headers: HeaderMap;
+};
+export interface Spec extends TurboModule {
+    request(config: SniConnectRequest): Promise<SniConnectResponse>;
+    cancelRequest(requestId: string): Promise<{
+        success: boolean;
+    }>;
+    cancelAllRequests(): Promise<{
+        success: boolean;
+    }>;
+    clearDNSCache(): Promise<{
+        success: boolean;
+    }>;
+    addListener(eventType: string): void;
+    removeListeners(count: Int32): void;
+}
+export type SniConnectModule = Spec & {
+    request(config: SniConnectRequest): Promise<SniConnectResponse>;
+    cancelRequest(requestId: string): Promise<{
+        success: boolean;
+    }>;
+    cancelAllRequests(): Promise<{
+        success: boolean;
+    }>;
+    clearDNSCache(): Promise<{
+        success: boolean;
+    }>;
+};
+declare const NativeSniConnect: SniConnectModule;
+export default NativeSniConnect;
+//# sourceMappingURL=NativeSniConnect.d.ts.map

package/lib/typescript/src/NativeSniConnect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeSniConnect.d.ts","sourceRoot":"","sources":["../../../src/NativeSniConnect.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,2CAA2C,CAAC;AAE/E,KAAK,SAAS,GAAG;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,SAAS,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,SAAS,CAAC;CACpB,CAAC;AAEF,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAChE,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAChE,iBAAiB,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACnD,aAAa,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAG/C,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrC;AAQD,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG;IACpC,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAChE,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAChE,iBAAiB,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACnD,aAAa,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAChD,CAAC;AAeF,QAAA,MAAM,gBAAgB,EAAE,gBAA+B,CAAC;AAExD,eAAe,gBAAgB,CAAC"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,19 @@
+import { type SniConnectRequest, type SniConnectResponse } from './NativeSniConnect';
+export type LogEntry = {
+    level: string;
+    message: string;
+    timestamp: number;
+};
+export declare function subscribeToLogs(callback: (log: LogEntry) => void): () => void;
+export declare function request(config: SniConnectRequest): Promise<SniConnectResponse>;
+export declare function cancelRequest(requestId: string): Promise<{
+    success: boolean;
+}>;
+export declare function cancelAllRequests(): Promise<{
+    success: boolean;
+}>;
+export declare function clearDNSCache(): Promise<{
+    success: boolean;
+}>;
+export type { SniConnectRequest, SniConnectResponse } from './NativeSniConnect';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAyB,EACvB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACxB,MAAM,oBAAoB,CAAC;AAG5B,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAMF,wBAAgB,eAAe,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,IAAI,GAAG,MAAM,IAAI,CAM7E;AAED,wBAAgB,OAAO,CACrB,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,kBAAkB,CAAC,CAE7B;AAED,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAE/B;AAED,wBAAgB,iBAAiB,IAAI,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAEjE;AAED,wBAAgB,aAAa,IAAI,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAE7D;AAED,YAAY,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}