react-native-nitro-cookies 0.0.1 → 1.0.0

package/android/src/main/java/com/margelo/nitro/nitrocookies/NitroCookies.kt

@@ -169,7 +169,101 @@ class NitroCookies : HybridNitroCookiesSpec() {
     return url
   }
 
-  // MARK: - Main Cookie Operations
+  // MARK: - Synchronous Cookie Operations
+
+  /** Get cookies synchronously for a URL */
+  override fun getSync(url: String): Array<Cookie> {
+    val urlObj = validateURL(url)
+    val cookieManager = CookieManager.getInstance()
+    val cookieString = cookieManager.getCookie(url)
+
+    if (cookieString.isNullOrEmpty()) {
+      return emptyArray()
+    }
+
+    // Parse cookie string (format: "name1=value1; name2=value2")
+    val cookies = mutableListOf<Cookie>()
+    val cookiePairs = cookieString.split(";").map { it.trim() }
+
+    for (pair in cookiePairs) {
+      val nameValue = pair.split("=", limit = 2)
+      if (nameValue.size == 2) {
+        cookies.add(
+          Cookie(
+            name = nameValue[0].trim(),
+            value = nameValue[1].trim(),
+            path = "/",
+            domain = urlObj.host,
+            version = null,
+            expires = null,
+            secure = null,
+            httpOnly = null
+          )
+        )
+      }
+    }
+
+    return cookies.toTypedArray()
+  }
+
+  /** Set a cookie synchronously */
+  override fun setSync(url: String, cookie: Cookie): Boolean {
+    val urlObj = validateURL(url)
+    validateDomain(cookie, urlObj)
+
+    // Apply defaults
+    val cookieWithDefaults =
+      cookie.copy(path = cookie.path ?: "/", domain = cookie.domain ?: urlObj.host)
+
+    val cookieManager = CookieManager.getInstance()
+    cookieManager.setAcceptCookie(true)
+
+    val setCookieString = toRFC6265String(cookieWithDefaults)
+    cookieManager.setCookie(url, setCookieString)
+
+    return true
+  }
+
+  /** Parse and set cookies from Set-Cookie header synchronously */
+  override fun setFromResponseSync(url: String, value: String): Boolean {
+    validateURL(url) // Validate URL format
+    val cookieManager = CookieManager.getInstance()
+    cookieManager.setAcceptCookie(true)
+
+    // Set-Cookie header can contain multiple cookies
+    val setCookieHeaders = value.split("\n").map { it.trim() }
+    for (header in setCookieHeaders) {
+      if (header.isNotEmpty()) {
+        cookieManager.setCookie(url, header)
+      }
+    }
+
+    return true
+  }
+
+  /** Clear a specific cookie by name synchronously */
+  override fun clearByNameSync(url: String, name: String): Boolean {
+    val urlObj = validateURL(url)
+    val cookieManager = CookieManager.getInstance()
+
+    // Check if the cookie exists for the given URL
+    val cookieString = cookieManager.getCookie(url)
+    val cookies = cookieString?.split(";")?.map { it.trim() } ?: emptyList()
+    val found = cookies.any { it.startsWith("$name=") }
+
+    if (found) {
+      // Android CookieManager doesn't support removing specific cookies by name
+      // We can only expire them by setting a past expiration date
+      val expiredCookie =
+        "$name=; Path=/; Domain=${urlObj.host}; Expires=Thu, 01 Jan 1970 00:00:00 GMT"
+      cookieManager.setCookie(url, expiredCookie)
+      return true
+    }
+
+    return false
+  }
+
+  // MARK: - Asynchronous Cookie Operations
 
   /** Set a single cookie */
   override fun set(url: String, cookie: Cookie, useWebKit: Boolean?): Promise<Boolean> {
@@ -289,19 +383,27 @@ class NitroCookies : HybridNitroCookiesSpec() {
     }
   }
 
-  /** Clear specific cookie by name (iOS only - not fully supported on Android) */
+  /** Clear specific cookie by name */
   override fun clearByName(url: String, name: String, useWebKit: Boolean?): Promise<Boolean> {
     return Promise.async {
       val urlObj = validateURL(url)
       val cookieManager = CookieManager.getInstance()
 
-      // Android CookieManager doesn't support removing specific cookies by name
-      // We can only expire them by setting a past expiration date
-      val expiredCookie =
-        "$name=; Path=/; Domain=${urlObj.host}; Expires=Thu, 01 Jan 1970 00:00:00 GMT"
-      cookieManager.setCookie(url, expiredCookie)
-
-      true
+      // Check if the cookie exists for the given URL
+      val cookieString = cookieManager.getCookie(url)
+      val cookies = cookieString?.split(";")?.map { it.trim() } ?: emptyList()
+      val found = cookies.any { it.startsWith("$name=") }
+
+      if (found) {
+        // Android CookieManager doesn't support removing specific cookies by name
+        // We can only expire them by setting a past expiration date
+        val expiredCookie =
+          "$name=; Path=/; Domain=${urlObj.host}; Expires=Thu, 01 Jan 1970 00:00:00 GMT"
+        cookieManager.setCookie(url, expiredCookie)
+        true
+      } else {
+        false
+      }
     }
   }
 

package/ios/NitroCookies.swift

@@ -134,7 +134,81 @@ public class HybridNitroCookies: HybridNitroCookiesSpec {
         return url
     }
 
-    // MARK: - Main Cookie Operations
+    // MARK: - Synchronous Cookie Operations
+
+    /**
+     * Get cookies synchronously for a URL
+     * Uses NSHTTPCookieStorage only (WebKit not supported for sync operations)
+     */
+    public func getSync(url urlString: String) throws -> [Cookie] {
+        let url = try validateURL(urlString)
+        let allCookies = HTTPCookieStorage.shared.cookies ?? []
+        let filteredCookies = allCookies.filter { cookie in
+            self.isMatchingDomain(cookieDomain: cookie.domain,
+                                 urlHost: url.host ?? "")
+        }
+        return filteredCookies.map { self.createCookieData(from: $0) }
+    }
+
+    /**
+     * Set a cookie synchronously
+     * Uses NSHTTPCookieStorage only (WebKit not supported for sync operations)
+     */
+    public func setSync(url urlString: String, cookie: Cookie) throws -> Bool {
+        let url = try validateURL(urlString)
+        try validateDomain(cookie: cookie, url: url)
+
+        // Apply defaults
+        var cookieWithDefaults = cookie
+        if cookieWithDefaults.path == nil {
+            cookieWithDefaults.path = "/"
+        }
+        if cookieWithDefaults.domain == nil {
+            cookieWithDefaults.domain = url.host
+        }
+
+        let httpCookie = try makeHTTPCookie(from: cookieWithDefaults, url: url)
+        HTTPCookieStorage.shared.setCookie(httpCookie)
+        return true
+    }
+
+    /**
+     * Parse and set cookies from Set-Cookie header synchronously
+     */
+    public func setFromResponseSync(url urlString: String, value: String) throws -> Bool {
+        let url = try validateURL(urlString)
+        let headerFields = ["Set-Cookie": value]
+        let cookies = HTTPCookie.cookies(withResponseHeaderFields: headerFields, for: url)
+
+        let storage = HTTPCookieStorage.shared
+        for cookie in cookies {
+            storage.setCookie(cookie)
+        }
+        return true
+    }
+
+    /**
+     * Clear a specific cookie by name synchronously
+     */
+    public func clearByNameSync(url urlString: String, name: String) throws -> Bool {
+        let url = try validateURL(urlString)
+        let storage = HTTPCookieStorage.shared
+        let cookies = storage.cookies ?? []
+        let matchingCookie = cookies.first { cookie in
+            cookie.name == name &&
+            self.isMatchingDomain(cookieDomain: cookie.domain,
+                                 urlHost: url.host ?? "")
+        }
+
+        if let cookie = matchingCookie {
+            storage.deleteCookie(cookie)
+            return true
+        } else {
+            return false
+        }
+    }
+
+    // MARK: - Asynchronous Cookie Operations
 
     /**
      * Set a single cookie

package/lib/module/index.js

@@ -13,22 +13,112 @@ function cookiesToDictionary(cookies) {
 /**
  * Main NitroCookies export object with all cookie management methods.
  *
+ * Supports both synchronous and asynchronous APIs:
+ * - Synchronous methods (getSync, setSync, etc.): Direct return values, no Promise overhead
+ * - Asynchronous methods (get, set, etc.): Return Promises for WebKit and network operations
+ *
  * @example
  * ```typescript
  * import NitroCookies from 'react-native-nitro-cookies';
  *
- * // Set a cookie
- * await NitroCookies.set('https://example.com', {
- *   name: 'session',
- *   value: 'abc123',
- *   secure: true,
- * });
+ * // Synchronous API (no await needed!)
+ * const cookies = NitroCookies.getSync('https://example.com');
+ * NitroCookies.setSync('https://example.com', { name: 'session', value: 'abc123' });
  *
- * // Get cookies
- * const cookies = await NitroCookies.get('https://example.com');
+ * // Asynchronous API (for WebKit/network operations)
+ * const cookies = await NitroCookies.get('https://example.com', true); // useWebKit
  * ```
  */
 export const NitroCookies = {
+  // ========================================
+  // SYNCHRONOUS METHODS
+  // ========================================
+
+  /**
+   * Get cookies synchronously for a URL.
+   *
+   * Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+   * Does NOT support WebKit cookie store (use async `get` with `useWebKit: true`).
+   *
+   * @param url - The URL to match cookies against (must include protocol)
+   * @returns Dictionary of cookies keyed by name
+   * @throws {Error} INVALID_URL - URL is malformed or missing protocol
+   *
+   * @example
+   * ```typescript
+   * // No await needed!
+   * const cookies = NitroCookies.getSync('https://example.com');
+   * console.log(cookies); // { session: { name: 'session', value: 'abc123', ... } }
+   * ```
+   */
+  getSync(url) {
+    return cookiesToDictionary(NitroCookiesHybridObject.getSync(url));
+  },
+  /**
+   * Set a cookie synchronously.
+   *
+   * Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+   * Does NOT support WebKit cookie store (use async `set` with `useWebKit: true`).
+   *
+   * @param url - The URL for which to set the cookie (must include protocol)
+   * @param cookie - The cookie object to store
+   * @returns true on success
+   * @throws {Error} INVALID_URL - URL is malformed or missing protocol
+   * @throws {Error} DOMAIN_MISMATCH - Cookie domain doesn't match URL host
+   *
+   * @example
+   * ```typescript
+   * // No await needed!
+   * NitroCookies.setSync('https://example.com', {
+   *   name: 'session',
+   *   value: 'abc123',
+   *   path: '/',
+   *   secure: true,
+   * });
+   * ```
+   */
+  setSync(url, cookie) {
+    return NitroCookiesHybridObject.setSync(url, cookie);
+  },
+  /**
+   * Parse and set cookies from Set-Cookie header synchronously.
+   *
+   * @param url - The URL associated with the Set-Cookie header
+   * @param value - The raw Set-Cookie header value
+   * @returns true on success
+   * @throws {Error} INVALID_URL - URL is malformed
+   *
+   * @example
+   * ```typescript
+   * NitroCookies.setFromResponseSync(
+   *   'https://example.com',
+   *   'session=abc123; path=/; secure; HttpOnly'
+   * );
+   * ```
+   */
+  setFromResponseSync(url, value) {
+    return NitroCookiesHybridObject.setFromResponseSync(url, value);
+  },
+  /**
+   * Clear a specific cookie by name synchronously.
+   *
+   * @param url - The URL to match the cookie domain
+   * @param name - The name of the cookie to remove
+   * @returns true if cookie was found and removed, false if not found
+   * @throws {Error} INVALID_URL - URL is malformed
+   *
+   * @example
+   * ```typescript
+   * const removed = NitroCookies.clearByNameSync('https://example.com', 'session');
+   * console.log(removed ? 'Cookie removed' : 'Cookie not found');
+   * ```
+   */
+  clearByNameSync(url, name) {
+    return NitroCookiesHybridObject.clearByNameSync(url, name);
+  },
+  // ========================================
+  // ASYNCHRONOUS METHODS
+  // ========================================
   /**
    * Set a single cookie for a specific URL.
    *

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","NitroCookiesHybridObject","createHybridObject","cookiesToDictionary","cookies","result","cookie","name","NitroCookies","set","url","useWebKit","get","clearAll","setFromResponse","value","getFromResponse","getAll","clearByName","flush","removeSessionCookies"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAIzD,MAAMC,wBAAwB,GAC5BD,YAAY,CAACE,kBAAkB,CAAmB,cAAc,CAAC;AAEnE,SAASC,mBAAmBA,CAACC,OAAiB,EAAW;EACvD,MAAMC,MAAe,GAAG,CAAC,CAAC;EAC1B,KAAK,MAAMC,MAAM,IAAIF,OAAO,EAAE;IAC5BC,MAAM,CAACC,MAAM,CAACC,IAAI,CAAC,GAAGD,MAAM;EAC9B;EACA,OAAOD,MAAM;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMG,YAAY,GAAG;EAC1B;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,GAAGA,CACPC,GAAW,EACXJ,MAAc,EACdK,SAAmB,EACD;IAClB,OAAOV,wBAAwB,CAACQ,GAAG,CAACC,GAAG,EAAEJ,MAAM,EAAEK,SAAS,IAAI,KAAK,CAAC;EACtE,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,GAAGA,CAACF,GAAW,EAAEC,SAAmB,EAAoB;IAC5D,MAAMP,OAAO,GAAG,MAAMH,wBAAwB,CAACW,GAAG,CAACF,GAAG,EAAEC,SAAS,IAAI,KAAK,CAAC;IAC3E,OAAOR,mBAAmB,CAACC,OAAO,CAAC;EACrC,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMS,QAAQA,CAACF,SAAmB,EAAoB;IACpD,OAAOV,wBAAwB,CAACY,QAAQ,CAACF,SAAS,IAAI,KAAK,CAAC;EAC9D,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMG,eAAeA,CAACJ,GAAW,EAAEK,KAAa,EAAoB;IAClE,OAAOd,wBAAwB,CAACa,eAAe,CAACJ,GAAG,EAAEK,KAAK,CAAC;EAC7D,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,eAAeA,CAACN,GAAW,EAAoB;IACnD,MAAMN,OAAO,GAAG,MAAMH,wBAAwB,CAACe,eAAe,CAACN,GAAG,CAAC;IACnE,OAAOP,mBAAmB,CAACC,OAAO,CAAC;EACrC,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMa,MAAMA,CAACN,SAAmB,EAAoB;IAClD,MAAMP,OAAO,GAAG,MAAMH,wBAAwB,CAACgB,MAAM,CAACN,SAAS,IAAI,KAAK,CAAC;IACzE,OAAOR,mBAAmB,CAACC,OAAO,CAAC;EACrC,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMc,WAAWA,CACfR,GAAW,EACXH,IAAY,EACZI,SAAmB,EACD;IAClB,OAAOV,wBAAwB,CAACiB,WAAW,CAACR,GAAG,EAAEH,IAAI,EAAEI,SAAS,IAAI,KAAK,CAAC;EAC5E,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMQ,KAAKA,CAAA,EAAkB;IAC3B,OAAOlB,wBAAwB,CAACkB,KAAK,CAAC,CAAC;EACzC,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,oBAAoBA,CAAA,EAAqB;IAC7C,OAAOnB,wBAAwB,CAACmB,oBAAoB,CAAC,CAAC;EACxD;AACF,CAAC;;AAED;;AAGA;AACA,eAAeZ,YAAY","ignoreList":[]}
+{"version":3,"names":["NitroModules","NitroCookiesHybridObject","createHybridObject","cookiesToDictionary","cookies","result","cookie","name","NitroCookies","getSync","url","setSync","setFromResponseSync","value","clearByNameSync","set","useWebKit","get","clearAll","setFromResponse","getFromResponse","getAll","clearByName","flush","removeSessionCookies"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAIzD,MAAMC,wBAAwB,GAC5BD,YAAY,CAACE,kBAAkB,CAAmB,cAAc,CAAC;AAEnE,SAASC,mBAAmBA,CAACC,OAAiB,EAAW;EACvD,MAAMC,MAAe,GAAG,CAAC,CAAC;EAC1B,KAAK,MAAMC,MAAM,IAAIF,OAAO,EAAE;IAC5BC,MAAM,CAACC,MAAM,CAACC,IAAI,CAAC,GAAGD,MAAM;EAC9B;EACA,OAAOD,MAAM;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMG,YAAY,GAAG;EAC1B;EACA;EACA;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,OAAOA,CAACC,GAAW,EAAW;IAC5B,OAAOP,mBAAmB,CAACF,wBAAwB,CAACQ,OAAO,CAACC,GAAG,CAAC,CAAC;EACnE,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,OAAOA,CAACD,GAAW,EAAEJ,MAAc,EAAW;IAC5C,OAAOL,wBAAwB,CAACU,OAAO,CAACD,GAAG,EAAEJ,MAAM,CAAC;EACtD,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEM,mBAAmBA,CAACF,GAAW,EAAEG,KAAa,EAAW;IACvD,OAAOZ,wBAAwB,CAACW,mBAAmB,CAACF,GAAG,EAAEG,KAAK,CAAC;EACjE,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,eAAeA,CAACJ,GAAW,EAAEH,IAAY,EAAW;IAClD,OAAON,wBAAwB,CAACa,eAAe,CAACJ,GAAG,EAAEH,IAAI,CAAC;EAC5D,CAAC;EAED;EACA;EACA;EACA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMQ,GAAGA,CACPL,GAAW,EACXJ,MAAc,EACdU,SAAmB,EACD;IAClB,OAAOf,wBAAwB,CAACc,GAAG,CAACL,GAAG,EAAEJ,MAAM,EAAEU,SAAS,IAAI,KAAK,CAAC;EACtE,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,GAAGA,CAACP,GAAW,EAAEM,SAAmB,EAAoB;IAC5D,MAAMZ,OAAO,GAAG,MAAMH,wBAAwB,CAACgB,GAAG,CAACP,GAAG,EAAEM,SAAS,IAAI,KAAK,CAAC;IAC3E,OAAOb,mBAAmB,CAACC,OAAO,CAAC;EACrC,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMc,QAAQA,CAACF,SAAmB,EAAoB;IACpD,OAAOf,wBAAwB,CAACiB,QAAQ,CAACF,SAAS,IAAI,KAAK,CAAC;EAC9D,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMG,eAAeA,CAACT,GAAW,EAAEG,KAAa,EAAoB;IAClE,OAAOZ,wBAAwB,CAACkB,eAAe,CAACT,GAAG,EAAEG,KAAK,CAAC;EAC7D,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMO,eAAeA,CAACV,GAAW,EAAoB;IACnD,MAAMN,OAAO,GAAG,MAAMH,wBAAwB,CAACmB,eAAe,CAACV,GAAG,CAAC;IACnE,OAAOP,mBAAmB,CAACC,OAAO,CAAC;EACrC,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMiB,MAAMA,CAACL,SAAmB,EAAoB;IAClD,MAAMZ,OAAO,GAAG,MAAMH,wBAAwB,CAACoB,MAAM,CAACL,SAAS,IAAI,KAAK,CAAC;IACzE,OAAOb,mBAAmB,CAACC,OAAO,CAAC;EACrC,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMkB,WAAWA,CACfZ,GAAW,EACXH,IAAY,EACZS,SAAmB,EACD;IAClB,OAAOf,wBAAwB,CAACqB,WAAW,CAACZ,GAAG,EAAEH,IAAI,EAAES,SAAS,IAAI,KAAK,CAAC;EAC5E,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMO,KAAKA,CAAA,EAAkB;IAC3B,OAAOtB,wBAAwB,CAACsB,KAAK,CAAC,CAAC;EACzC,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,oBAAoBA,CAAA,EAAqB;IAC7C,OAAOvB,wBAAwB,CAACuB,oBAAoB,CAAC,CAAC;EACxD;AACF,CAAC;;AAED;;AAGA;AACA,eAAehB,YAAY","ignoreList":[]}

package/lib/typescript/src/NitroCookies.nitro.d.ts

@@ -13,11 +13,55 @@ import type { Cookie } from './types';
  * Uses Nitro Modules JSI architecture to achieve 5x+ faster operations compared
  * to traditional React Native bridge-based implementations.
  *
+ * API Design:
+ * - Synchronous methods (xxxSync): Direct return values, no Promise wrapping
+ * - Asynchronous methods: Return Promise for operations requiring callbacks/network
  */
 export interface NitroCookies extends HybridObject<{
     ios: 'swift';
     android: 'kotlin';
 }> {
+    /**
+     * Get cookies synchronously for a URL
+     *
+     * Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+     * Does NOT support WebKit cookie store (use async `get` with `useWebKit: true`).
+     *
+     * @param url - The URL to match cookies against (must include protocol)
+     * @returns Array of cookies matching the URL domain
+     * @throws Error if URL is invalid
+     */
+    getSync(url: string): Cookie[];
+    /**
+     * Set a cookie synchronously
+     *
+     * Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+     * Does NOT support WebKit cookie store (use async `set` with `useWebKit: true`).
+     *
+     * @param url - The URL for which to set the cookie (must include protocol)
+     * @param cookie - The cookie object to store
+     * @returns true on success
+     * @throws Error if URL is invalid or domain mismatch
+     */
+    setSync(url: string, cookie: Cookie): boolean;
+    /**
+     * Parse and set cookies from Set-Cookie header synchronously
+     *
+     * @param url - The URL associated with the Set-Cookie header
+     * @param value - The raw Set-Cookie header value
+     * @returns true on success
+     * @throws Error if URL is invalid
+     */
+    setFromResponseSync(url: string, value: string): boolean;
+    /**
+     * Clear a specific cookie by name synchronously
+     *
+     * @param url - The URL to match the cookie domain
+     * @param name - The name of the cookie to remove
+     * @returns true if cookie was found and removed, false if not found
+     * @throws Error if URL is invalid
+     */
+    clearByNameSync(url: string, name: string): boolean;
     /**
      * Set a single cookie for a specific URL
      *

package/lib/typescript/src/NitroCookies.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NitroCookies.nitro.d.ts","sourceRoot":"","sources":["../../../src/NitroCookies.nitro.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAKtC;;;;;;;GAOG;AACH,MAAM,WAAW,YACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD;;;;;;;OAOG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAExE;;;;;;OAMG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEzD;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEhD;;;;;;OAMG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9D;;;;;OAKG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEhD;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAE/C;;;;;;;OAOG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9E;;;;OAIG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;;OAIG;IACH,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1C"}
+{"version":3,"file":"NitroCookies.nitro.d.ts","sourceRoot":"","sources":["../../../src/NitroCookies.nitro.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAKtC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,YACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAKzD;;;;;;;;;OASG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE/B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAE9C;;;;;;;OAOG;IACH,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAEzD;;;;;;;OAOG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAMpD;;;;;;;OAOG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAExE;;;;;;OAMG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEzD;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEhD;;;;;;OAMG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9D;;;;;OAKG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEhD;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAE/C;;;;;;;OAOG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9E;;;;OAIG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;;OAIG;IACH,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1C"}

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

@@ -2,22 +2,97 @@ import type { Cookie, Cookies, CookieErrorCode, CookieError } from './types';
 /**
  * Main NitroCookies export object with all cookie management methods.
  *
+ * Supports both synchronous and asynchronous APIs:
+ * - Synchronous methods (getSync, setSync, etc.): Direct return values, no Promise overhead
+ * - Asynchronous methods (get, set, etc.): Return Promises for WebKit and network operations
+ *
  * @example
  * ```typescript
  * import NitroCookies from 'react-native-nitro-cookies';
  *
- * // Set a cookie
- * await NitroCookies.set('https://example.com', {
- *   name: 'session',
- *   value: 'abc123',
- *   secure: true,
- * });
+ * // Synchronous API (no await needed!)
+ * const cookies = NitroCookies.getSync('https://example.com');
+ * NitroCookies.setSync('https://example.com', { name: 'session', value: 'abc123' });
  *
- * // Get cookies
- * const cookies = await NitroCookies.get('https://example.com');
+ * // Asynchronous API (for WebKit/network operations)
+ * const cookies = await NitroCookies.get('https://example.com', true); // useWebKit
  * ```
  */
 export declare const NitroCookies: {
+    /**
+     * Get cookies synchronously for a URL.
+     *
+     * Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+     * Does NOT support WebKit cookie store (use async `get` with `useWebKit: true`).
+     *
+     * @param url - The URL to match cookies against (must include protocol)
+     * @returns Dictionary of cookies keyed by name
+     * @throws {Error} INVALID_URL - URL is malformed or missing protocol
+     *
+     * @example
+     * ```typescript
+     * // No await needed!
+     * const cookies = NitroCookies.getSync('https://example.com');
+     * console.log(cookies); // { session: { name: 'session', value: 'abc123', ... } }
+     * ```
+     */
+    getSync(url: string): Cookies;
+    /**
+     * Set a cookie synchronously.
+     *
+     * Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+     * Does NOT support WebKit cookie store (use async `set` with `useWebKit: true`).
+     *
+     * @param url - The URL for which to set the cookie (must include protocol)
+     * @param cookie - The cookie object to store
+     * @returns true on success
+     * @throws {Error} INVALID_URL - URL is malformed or missing protocol
+     * @throws {Error} DOMAIN_MISMATCH - Cookie domain doesn't match URL host
+     *
+     * @example
+     * ```typescript
+     * // No await needed!
+     * NitroCookies.setSync('https://example.com', {
+     *   name: 'session',
+     *   value: 'abc123',
+     *   path: '/',
+     *   secure: true,
+     * });
+     * ```
+     */
+    setSync(url: string, cookie: Cookie): boolean;
+    /**
+     * Parse and set cookies from Set-Cookie header synchronously.
+     *
+     * @param url - The URL associated with the Set-Cookie header
+     * @param value - The raw Set-Cookie header value
+     * @returns true on success
+     * @throws {Error} INVALID_URL - URL is malformed
+     *
+     * @example
+     * ```typescript
+     * NitroCookies.setFromResponseSync(
+     *   'https://example.com',
+     *   'session=abc123; path=/; secure; HttpOnly'
+     * );
+     * ```
+     */
+    setFromResponseSync(url: string, value: string): boolean;
+    /**
+     * Clear a specific cookie by name synchronously.
+     *
+     * @param url - The URL to match the cookie domain
+     * @param name - The name of the cookie to remove
+     * @returns true if cookie was found and removed, false if not found
+     * @throws {Error} INVALID_URL - URL is malformed
+     *
+     * @example
+     * ```typescript
+     * const removed = NitroCookies.clearByNameSync('https://example.com', 'session');
+     * console.log(removed ? 'Cookie removed' : 'Cookie not found');
+     * ```
+     */
+    clearByNameSync(url: string, name: string): boolean;
     /**
      * Set a single cookie for a specific URL.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAa7E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;aAEI,MAAM,UACH,MAAM,cACF,OAAO,GAClB,OAAO,CAAC,OAAO,CAAC;IAInB;;;;;;;;;;;;;;;;;;;OAmBG;aACY,MAAM,cAAc,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAK7D;;;;;;;;;;;;OAYG;yBACwB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrD;;;;;;;;;;;;;;;;;;;;;OAqBG;yBACwB,MAAM,SAAS,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAInE;;;;;;;;;;;;;;;;;;OAkBG;yBACwB,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKpD;;;;;;;;;;;;;;;;;;;;;;OAsBG;uBACsB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAKnD;;;;;;;;;;;;;;;;;;;;;OAqBG;qBAEI,MAAM,QACL,MAAM,cACA,OAAO,GAClB,OAAO,CAAC,OAAO,CAAC;IAInB;;;;;;;;;;;;;;;;;;;;OAoBG;aACY,OAAO,CAAC,IAAI,CAAC;IAI5B;;;;;;;;;;;;;;;;;;;;;OAqBG;4BAC2B,OAAO,CAAC,OAAO,CAAC;CAG/C,CAAC;AAGF,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,CAAC;AAG9D,eAAe,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAa7E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY;IAKvB;;;;;;;;;;;;;;;;OAgBG;iBACU,MAAM,GAAG,OAAO;IAI7B;;;;;;;;;;;;;;;;;;;;;;OAsBG;iBACU,MAAM,UAAU,MAAM,GAAG,OAAO;IAI7C;;;;;;;;;;;;;;;OAeG;6BACsB,MAAM,SAAS,MAAM,GAAG,OAAO;IAIxD;;;;;;;;;;;;;OAaG;yBACkB,MAAM,QAAQ,MAAM,GAAG,OAAO;IAOnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;aAEI,MAAM,UACH,MAAM,cACF,OAAO,GAClB,OAAO,CAAC,OAAO,CAAC;IAInB;;;;;;;;;;;;;;;;;;;OAmBG;aACY,MAAM,cAAc,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAK7D;;;;;;;;;;;;OAYG;yBACwB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrD;;;;;;;;;;;;;;;;;;;;;OAqBG;yBACwB,MAAM,SAAS,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAInE;;;;;;;;;;;;;;;;;;OAkBG;yBACwB,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKpD;;;;;;;;;;;;;;;;;;;;;;OAsBG;uBACsB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAKnD;;;;;;;;;;;;;;;;;;;;;OAqBG;qBAEI,MAAM,QACL,MAAM,cACA,OAAO,GAClB,OAAO,CAAC,OAAO,CAAC;IAInB;;;;;;;;;;;;;;;;;;;;OAoBG;aACY,OAAO,CAAC,IAAI,CAAC;IAI5B;;;;;;;;;;;;;;;;;;;;;OAqBG;4BAC2B,OAAO,CAAC,OAAO,CAAC;CAG/C,CAAC;AAGF,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,CAAC;AAG9D,eAAe,YAAY,CAAC"}

package/nitrogen/generated/android/c++/JHybridNitroCookiesSpec.cpp

@@ -10,13 +10,13 @@
 // Forward declaration of `Cookie` to properly resolve imports.
 namespace margelo::nitro::nitrocookies { struct Cookie; }
 
-#include <NitroModules/Promise.hpp>
-#include <NitroModules/JPromise.hpp>
 #include "Cookie.hpp"
 #include <vector>
 #include "JCookie.hpp"
 #include <string>
 #include <optional>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
 
 namespace margelo::nitro::nitrocookies {
 
@@ -50,6 +50,35 @@ namespace margelo::nitro::nitrocookies {
   
 
   // Methods
+  std::vector<Cookie> JHybridNitroCookiesSpec::getSync(const std::string& url) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JCookie>>(jni::alias_ref<jni::JString> /* url */)>("getSync");
+    auto __result = method(_javaPart, jni::make_jstring(url));
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<Cookie> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }();
+  }
+  bool JHybridNitroCookiesSpec::setSync(const std::string& url, const Cookie& cookie) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<JCookie> /* cookie */)>("setSync");
+    auto __result = method(_javaPart, jni::make_jstring(url), JCookie::fromCpp(cookie));
+    return static_cast<bool>(__result);
+  }
+  bool JHybridNitroCookiesSpec::setFromResponseSync(const std::string& url, const std::string& value) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JString> /* value */)>("setFromResponseSync");
+    auto __result = method(_javaPart, jni::make_jstring(url), jni::make_jstring(value));
+    return static_cast<bool>(__result);
+  }
+  bool JHybridNitroCookiesSpec::clearByNameSync(const std::string& url, const std::string& name) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JString> /* name */)>("clearByNameSync");
+    auto __result = method(_javaPart, jni::make_jstring(url), jni::make_jstring(name));
+    return static_cast<bool>(__result);
+  }
   std::shared_ptr<Promise<bool>> JHybridNitroCookiesSpec::set(const std::string& url, const Cookie& cookie, std::optional<bool> useWebKit) {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<JCookie> /* cookie */, jni::alias_ref<jni::JBoolean> /* useWebKit */)>("set");
     auto __result = method(_javaPart, jni::make_jstring(url), JCookie::fromCpp(cookie), useWebKit.has_value() ? jni::JBoolean::valueOf(useWebKit.value()) : nullptr);

package/nitrogen/generated/android/c++/JHybridNitroCookiesSpec.hpp

@@ -54,6 +54,10 @@ namespace margelo::nitro::nitrocookies {
 
   public:
     // Methods
+    std::vector<Cookie> getSync(const std::string& url) override;
+    bool setSync(const std::string& url, const Cookie& cookie) override;
+    bool setFromResponseSync(const std::string& url, const std::string& value) override;
+    bool clearByNameSync(const std::string& url, const std::string& name) override;
     std::shared_ptr<Promise<bool>> set(const std::string& url, const Cookie& cookie, std::optional<bool> useWebKit) override;
     std::shared_ptr<Promise<std::vector<Cookie>>> get(const std::string& url, std::optional<bool> useWebKit) override;
     std::shared_ptr<Promise<bool>> clearAll(std::optional<bool> useWebKit) override;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrocookies/HybridNitroCookiesSpec.kt

@@ -46,6 +46,22 @@ abstract class HybridNitroCookiesSpec: HybridObject() {
   
 
   // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun getSync(url: String): Array<Cookie>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setSync(url: String, cookie: Cookie): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setFromResponseSync(url: String, value: String): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun clearByNameSync(url: String, name: String): Boolean
+  
   @DoNotStrip
   @Keep
   abstract fun set(url: String, cookie: Cookie, useWebKit: Boolean?): Promise<Boolean>

package/nitrogen/generated/ios/NitroCookies-Swift-Cxx-Bridge.hpp

@@ -36,6 +36,47 @@ namespace NitroCookies { class HybridNitroCookiesSpec_cxx; }
  */
 namespace margelo::nitro::nitrocookies::bridge::swift {
 
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<Cookie>
+  /**
+   * Specialized version of `std::vector<Cookie>`.
+   */
+  using std__vector_Cookie_ = std::vector<Cookie>;
+  inline std::vector<Cookie> create_std__vector_Cookie_(size_t size) noexcept {
+    std::vector<Cookie> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<bool>>
   /**
    * Specialized version of `std::shared_ptr<Promise<bool>>`.
@@ -92,47 +133,6 @@ namespace margelo::nitro::nitrocookies::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<std::string>
-  /**
-   * Specialized version of `std::optional<std::string>`.
-   */
-  using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
-    return std::optional<std::string>(value);
-  }
-  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return *optional;
-  }
-  
-  // pragma MARK: std::optional<bool>
-  /**
-   * Specialized version of `std::optional<bool>`.
-   */
-  using std__optional_bool_ = std::optional<bool>;
-  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
-    return std::optional<bool>(value);
-  }
-  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
-    return *optional;
-  }
-  
-  // pragma MARK: std::vector<Cookie>
-  /**
-   * Specialized version of `std::vector<Cookie>`.
-   */
-  using std__vector_Cookie_ = std::vector<Cookie>;
-  inline std::vector<Cookie> create_std__vector_Cookie_(size_t size) noexcept {
-    std::vector<Cookie> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
   // pragma MARK: std::shared_ptr<Promise<std::vector<Cookie>>>
   /**
    * Specialized version of `std::shared_ptr<Promise<std::vector<Cookie>>>`.
@@ -213,6 +213,24 @@ namespace margelo::nitro::nitrocookies::bridge::swift {
   using std__weak_ptr_HybridNitroCookiesSpec_ = std::weak_ptr<HybridNitroCookiesSpec>;
   inline std__weak_ptr_HybridNitroCookiesSpec_ weakify_std__shared_ptr_HybridNitroCookiesSpec_(const std::shared_ptr<HybridNitroCookiesSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: Result<std::vector<Cookie>>
+  using Result_std__vector_Cookie__ = Result<std::vector<Cookie>>;
+  inline Result_std__vector_Cookie__ create_Result_std__vector_Cookie__(const std::vector<Cookie>& value) noexcept {
+    return Result<std::vector<Cookie>>::withValue(value);
+  }
+  inline Result_std__vector_Cookie__ create_Result_std__vector_Cookie__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<Cookie>>::withError(error);
+  }
+  
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
+    return Result<bool>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
   using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
   inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {

package/nitrogen/generated/ios/c++/HybridNitroCookiesSpecSwift.hpp

@@ -15,11 +15,11 @@ namespace NitroCookies { class HybridNitroCookiesSpec_cxx; }
 // Forward declaration of `Cookie` to properly resolve imports.
 namespace margelo::nitro::nitrocookies { struct Cookie; }
 
-#include <NitroModules/Promise.hpp>
-#include <string>
 #include "Cookie.hpp"
-#include <optional>
 #include <vector>
+#include <string>
+#include <optional>
+#include <NitroModules/Promise.hpp>
 
 #include "NitroCookies-Swift-Cxx-Umbrella.hpp"
 
@@ -65,6 +65,38 @@ namespace margelo::nitro::nitrocookies {
 
   public:
     // Methods
+    inline std::vector<Cookie> getSync(const std::string& url) override {
+      auto __result = _swiftPart.getSync(url);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool setSync(const std::string& url, const Cookie& cookie) override {
+      auto __result = _swiftPart.setSync(url, std::forward<decltype(cookie)>(cookie));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool setFromResponseSync(const std::string& url, const std::string& value) override {
+      auto __result = _swiftPart.setFromResponseSync(url, value);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool clearByNameSync(const std::string& url, const std::string& name) override {
+      auto __result = _swiftPart.clearByNameSync(url, name);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<bool>> set(const std::string& url, const Cookie& cookie, std::optional<bool> useWebKit) override {
       auto __result = _swiftPart.set(url, std::forward<decltype(cookie)>(cookie), useWebKit);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridNitroCookiesSpec.swift

@@ -15,6 +15,10 @@ public protocol HybridNitroCookiesSpec_protocol: HybridObject {
   
 
   // Methods
+  func getSync(url: String) throws -> [Cookie]
+  func setSync(url: String, cookie: Cookie) throws -> Bool
+  func setFromResponseSync(url: String, value: String) throws -> Bool
+  func clearByNameSync(url: String, name: String) throws -> Bool
   func set(url: String, cookie: Cookie, useWebKit: Bool?) throws -> Promise<Bool>
   func get(url: String, useWebKit: Bool?) throws -> Promise<[Cookie]>
   func clearAll(useWebKit: Bool?) throws -> Promise<Bool>

package/nitrogen/generated/ios/swift/HybridNitroCookiesSpec_cxx.swift

@@ -118,6 +118,60 @@ open class HybridNitroCookiesSpec_cxx {
   
 
   // Methods
+  @inline(__always)
+  public final func getSync(url: std.string) -> bridge.Result_std__vector_Cookie__ {
+    do {
+      let __result = try self.__implementation.getSync(url: String(url))
+      let __resultCpp = { () -> bridge.std__vector_Cookie_ in
+        var __vector = bridge.create_std__vector_Cookie_(__result.count)
+        for __item in __result {
+          __vector.push_back(__item)
+        }
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_Cookie__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_Cookie__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setSync(url: std.string, cookie: Cookie) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.setSync(url: String(url), cookie: cookie)
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setFromResponseSync(url: std.string, value: std.string) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.setFromResponseSync(url: String(url), value: String(value))
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func clearByNameSync(url: std.string, name: std.string) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.clearByNameSync(url: String(url), name: String(name))
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func set(url: std.string, cookie: Cookie, useWebKit: bridge.std__optional_bool_) -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {

package/nitrogen/generated/shared/c++/HybridNitroCookiesSpec.cpp

@@ -14,6 +14,10 @@ namespace margelo::nitro::nitrocookies {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("getSync", &HybridNitroCookiesSpec::getSync);
+      prototype.registerHybridMethod("setSync", &HybridNitroCookiesSpec::setSync);
+      prototype.registerHybridMethod("setFromResponseSync", &HybridNitroCookiesSpec::setFromResponseSync);
+      prototype.registerHybridMethod("clearByNameSync", &HybridNitroCookiesSpec::clearByNameSync);
       prototype.registerHybridMethod("set", &HybridNitroCookiesSpec::set);
       prototype.registerHybridMethod("get", &HybridNitroCookiesSpec::get);
       prototype.registerHybridMethod("clearAll", &HybridNitroCookiesSpec::clearAll);

package/nitrogen/generated/shared/c++/HybridNitroCookiesSpec.hpp

@@ -16,11 +16,11 @@
 // Forward declaration of `Cookie` to properly resolve imports.
 namespace margelo::nitro::nitrocookies { struct Cookie; }
 
-#include <NitroModules/Promise.hpp>
-#include <string>
 #include "Cookie.hpp"
-#include <optional>
 #include <vector>
+#include <string>
+#include <NitroModules/Promise.hpp>
+#include <optional>
 
 namespace margelo::nitro::nitrocookies {
 
@@ -53,6 +53,10 @@ namespace margelo::nitro::nitrocookies {
 
     public:
       // Methods
+      virtual std::vector<Cookie> getSync(const std::string& url) = 0;
+      virtual bool setSync(const std::string& url, const Cookie& cookie) = 0;
+      virtual bool setFromResponseSync(const std::string& url, const std::string& value) = 0;
+      virtual bool clearByNameSync(const std::string& url, const std::string& name) = 0;
       virtual std::shared_ptr<Promise<bool>> set(const std::string& url, const Cookie& cookie, std::optional<bool> useWebKit) = 0;
       virtual std::shared_ptr<Promise<std::vector<Cookie>>> get(const std::string& url, std::optional<bool> useWebKit) = 0;
       virtual std::shared_ptr<Promise<bool>> clearAll(std::optional<bool> useWebKit) = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-cookies",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "description": "Fetch, Get Cookies 🍪 at the Speed of Nitro",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/NitroCookies.nitro.ts

@@ -18,9 +18,65 @@ import type { Cookie } from './types';
  * Uses Nitro Modules JSI architecture to achieve 5x+ faster operations compared
  * to traditional React Native bridge-based implementations.
  *
+ * API Design:
+ * - Synchronous methods (xxxSync): Direct return values, no Promise wrapping
+ * - Asynchronous methods: Return Promise for operations requiring callbacks/network
  */
 export interface NitroCookies
   extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
+  // ========================================
+  // SYNCHRONOUS METHODS
+  // ========================================
+
+  /**
+   * Get cookies synchronously for a URL
+   *
+   * Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+   * Does NOT support WebKit cookie store (use async `get` with `useWebKit: true`).
+   *
+   * @param url - The URL to match cookies against (must include protocol)
+   * @returns Array of cookies matching the URL domain
+   * @throws Error if URL is invalid
+   */
+  getSync(url: string): Cookie[];
+
+  /**
+   * Set a cookie synchronously
+   *
+   * Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+   * Does NOT support WebKit cookie store (use async `set` with `useWebKit: true`).
+   *
+   * @param url - The URL for which to set the cookie (must include protocol)
+   * @param cookie - The cookie object to store
+   * @returns true on success
+   * @throws Error if URL is invalid or domain mismatch
+   */
+  setSync(url: string, cookie: Cookie): boolean;
+
+  /**
+   * Parse and set cookies from Set-Cookie header synchronously
+   *
+   * @param url - The URL associated with the Set-Cookie header
+   * @param value - The raw Set-Cookie header value
+   * @returns true on success
+   * @throws Error if URL is invalid
+   */
+  setFromResponseSync(url: string, value: string): boolean;
+
+  /**
+   * Clear a specific cookie by name synchronously
+   *
+   * @param url - The URL to match the cookie domain
+   * @param name - The name of the cookie to remove
+   * @returns true if cookie was found and removed, false if not found
+   * @throws Error if URL is invalid
+   */
+  clearByNameSync(url: string, name: string): boolean;
+
+  // ========================================
+  // ASYNCHRONOUS METHODS
+  // ========================================
+
   /**
    * Set a single cookie for a specific URL
    *

package/src/index.tsx

@@ -16,22 +16,116 @@ function cookiesToDictionary(cookies: Cookie[]): Cookies {
 /**
  * Main NitroCookies export object with all cookie management methods.
  *
+ * Supports both synchronous and asynchronous APIs:
+ * - Synchronous methods (getSync, setSync, etc.): Direct return values, no Promise overhead
+ * - Asynchronous methods (get, set, etc.): Return Promises for WebKit and network operations
+ *
  * @example
  * ```typescript
  * import NitroCookies from 'react-native-nitro-cookies';
  *
- * // Set a cookie
- * await NitroCookies.set('https://example.com', {
- *   name: 'session',
- *   value: 'abc123',
- *   secure: true,
- * });
+ * // Synchronous API (no await needed!)
+ * const cookies = NitroCookies.getSync('https://example.com');
+ * NitroCookies.setSync('https://example.com', { name: 'session', value: 'abc123' });
  *
- * // Get cookies
- * const cookies = await NitroCookies.get('https://example.com');
+ * // Asynchronous API (for WebKit/network operations)
+ * const cookies = await NitroCookies.get('https://example.com', true); // useWebKit
  * ```
  */
 export const NitroCookies = {
+  // ========================================
+  // SYNCHRONOUS METHODS
+  // ========================================
+
+  /**
+   * Get cookies synchronously for a URL.
+   *
+   * Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+   * Does NOT support WebKit cookie store (use async `get` with `useWebKit: true`).
+   *
+   * @param url - The URL to match cookies against (must include protocol)
+   * @returns Dictionary of cookies keyed by name
+   * @throws {Error} INVALID_URL - URL is malformed or missing protocol
+   *
+   * @example
+   * ```typescript
+   * // No await needed!
+   * const cookies = NitroCookies.getSync('https://example.com');
+   * console.log(cookies); // { session: { name: 'session', value: 'abc123', ... } }
+   * ```
+   */
+  getSync(url: string): Cookies {
+    return cookiesToDictionary(NitroCookiesHybridObject.getSync(url));
+  },
+
+  /**
+   * Set a cookie synchronously.
+   *
+   * Uses NSHTTPCookieStorage (iOS) or CookieManager (Android).
+   * Does NOT support WebKit cookie store (use async `set` with `useWebKit: true`).
+   *
+   * @param url - The URL for which to set the cookie (must include protocol)
+   * @param cookie - The cookie object to store
+   * @returns true on success
+   * @throws {Error} INVALID_URL - URL is malformed or missing protocol
+   * @throws {Error} DOMAIN_MISMATCH - Cookie domain doesn't match URL host
+   *
+   * @example
+   * ```typescript
+   * // No await needed!
+   * NitroCookies.setSync('https://example.com', {
+   *   name: 'session',
+   *   value: 'abc123',
+   *   path: '/',
+   *   secure: true,
+   * });
+   * ```
+   */
+  setSync(url: string, cookie: Cookie): boolean {
+    return NitroCookiesHybridObject.setSync(url, cookie);
+  },
+
+  /**
+   * Parse and set cookies from Set-Cookie header synchronously.
+   *
+   * @param url - The URL associated with the Set-Cookie header
+   * @param value - The raw Set-Cookie header value
+   * @returns true on success
+   * @throws {Error} INVALID_URL - URL is malformed
+   *
+   * @example
+   * ```typescript
+   * NitroCookies.setFromResponseSync(
+   *   'https://example.com',
+   *   'session=abc123; path=/; secure; HttpOnly'
+   * );
+   * ```
+   */
+  setFromResponseSync(url: string, value: string): boolean {
+    return NitroCookiesHybridObject.setFromResponseSync(url, value);
+  },
+
+  /**
+   * Clear a specific cookie by name synchronously.
+   *
+   * @param url - The URL to match the cookie domain
+   * @param name - The name of the cookie to remove
+   * @returns true if cookie was found and removed, false if not found
+   * @throws {Error} INVALID_URL - URL is malformed
+   *
+   * @example
+   * ```typescript
+   * const removed = NitroCookies.clearByNameSync('https://example.com', 'session');
+   * console.log(removed ? 'Cookie removed' : 'Cookie not found');
+   * ```
+   */
+  clearByNameSync(url: string, name: string): boolean {
+    return NitroCookiesHybridObject.clearByNameSync(url, name);
+  },
+
+  // ========================================
+  // ASYNCHRONOUS METHODS
+  // ========================================
   /**
    * Set a single cookie for a specific URL.
    *