react-native-nitro-fetch 0.1.2 → 0.1.4

package/nitrogen/generated/ios/swift/HybridNativeStorageSpec.swift

@@ -0,0 +1,51 @@
+///
+/// HybridNativeStorageSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/// See ``HybridNativeStorageSpec``
+public protocol HybridNativeStorageSpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  func getString(key: String) throws -> String
+  func setString(key: String, value: String) throws -> Void
+  func removeString(key: String) throws -> Void
+}
+
+/// See ``HybridNativeStorageSpec``
+open class HybridNativeStorageSpec_base {
+  private weak var cxxWrapper: HybridNativeStorageSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridNativeStorageSpec_cxx {
+  #if DEBUG
+    guard self is HybridNativeStorageSpec else {
+      fatalError("`self` is not a `HybridNativeStorageSpec`! Did you accidentally inherit from `HybridNativeStorageSpec_base` instead of `HybridNativeStorageSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridNativeStorageSpec_cxx(self as! HybridNativeStorageSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the NativeStorage HybridObject.
+ * Implement this protocol to create Swift-based instances of NativeStorage.
+ * ```swift
+ * class HybridNativeStorage : HybridNativeStorageSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridNativeStorageSpec = HybridNativeStorageSpec_protocol & HybridNativeStorageSpec_base

package/nitrogen/generated/ios/swift/HybridNativeStorageSpec_cxx.swift

@@ -0,0 +1,145 @@
+///
+/// HybridNativeStorageSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridNativeStorageSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridNativeStorageSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::nitrofetch::bridge::swift`)
+   * from `NitroFetch-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.nitrofetch.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridNativeStorageSpec` Swift protocol.
+   */
+  private var __implementation: any HybridNativeStorageSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridNativeStorageSpec_
+
+  /**
+   * Create a new `HybridNativeStorageSpec_cxx` that wraps the given `HybridNativeStorageSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridNativeStorageSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridNativeStorageSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridNativeStorageSpec() -> any HybridNativeStorageSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridNativeStorageSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridNativeStorageSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridNativeStorageSpec_cxx {
+    return Unmanaged<HybridNativeStorageSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridNativeStorageSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridNativeStorageSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if cachedCxxPart.__convertToBool() {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridNativeStorageSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridNativeStorageSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  // Properties
+  
+
+  // Methods
+  @inline(__always)
+  public final func getString(key: std.string) -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.getString(key: String(key))
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__string_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setString(key: std.string, value: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setString(key: String(key), value: String(value))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func removeString(key: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.removeString(key: String(key))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+}

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

@@ -0,0 +1,23 @@
+///
+/// HybridNativeStorageSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridNativeStorageSpec.hpp"
+
+namespace margelo::nitro::nitrofetch {
+
+  void HybridNativeStorageSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("getString", &HybridNativeStorageSpec::getString);
+      prototype.registerHybridMethod("setString", &HybridNativeStorageSpec::setString);
+      prototype.registerHybridMethod("removeString", &HybridNativeStorageSpec::removeString);
+    });
+  }
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -0,0 +1,64 @@
+///
+/// HybridNativeStorageSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::nitrofetch {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NativeStorage`
+   * Inherit this class to create instances of `HybridNativeStorageSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNativeStorage: public HybridNativeStorageSpec {
+   * public:
+   *   HybridNativeStorage(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNativeStorageSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNativeStorageSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNativeStorageSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::string getString(const std::string& key) = 0;
+      virtual void setString(const std::string& key, const std::string& value) = 0;
+      virtual void removeString(const std::string& key) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NativeStorage";
+  };
+
+} // namespace margelo::nitro::nitrofetch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-fetch",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Awesome Fetch :)",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",
@@ -37,13 +37,12 @@
     "!**/.*"
   ],
   "scripts": {
-    "example": "yarn workspace react-native-nitro-fetch-example",
     "test": "jest",
     "typecheck": "tsc",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
     "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
     "prepare": "bob build",
-    "nitrogen": "nitro-codegen",
+    "nitrogen": "nitrogen",
     "release": "release-it --only-version"
   },
   "keywords": [
@@ -53,14 +52,14 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+http://google.com.git"
+    "url": "git+https://github.com/margelo/react-native-nitro-fetch.git"
   },
   "author": "Szymon Kapala <szymon20000@gmail.com'> (https://x.com/Turbo_Szymon)",
   "license": "MIT",
   "bugs": {
-    "url": "http://google.com/issues"
+    "url": "https://github.com/margelo/react-native-nitro-fetch/issues"
   },
-  "homepage": "http://google.com#readme",
+  "homepage": "https://github.com/margelo/react-native-nitro-fetch#readme",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
@@ -81,7 +80,7 @@
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-prettier": "^5.2.3",
     "jest": "^29.7.0",
-    "nitro-codegen": "^0.29.2",
+    "nitrogen": "^0.29.2",
     "prettier": "^3.0.3",
     "react": "19.1.0",
     "react-native": "0.81.0",
@@ -113,28 +112,13 @@
       "<rootDir>/lib/"
     ]
   },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
   "release-it": {
-    "git": {
-      "commitMessage": "chore: release ${version}",
-      "tagName": "v${version}"
-    },
+    "git": false,
     "npm": {
       "publish": true
     },
     "github": {
-      "release": true
-    },
-    "plugins": {
-      "@release-it/conventional-changelog": {
-        "preset": {
-          "name": "angular"
-        }
-      }
+      "release": false
     }
   },
   "prettier": {

package/src/NitroFetch.nitro.ts

@@ -10,10 +10,10 @@ export type NitroRequestMethod =
   | 'DELETE'
   | 'OPTIONS';
 
-export interface NitroHeader  {
+export interface NitroHeader {
   key: string;
   value: string;
-};
+}
 export interface NitroRequest {
   url: string;
   method?: NitroRequestMethod;
@@ -21,7 +21,7 @@ export interface NitroRequest {
   headers?: NitroHeader[];
   // Body as either UTF-8 string or raw bytes.
   bodyString?: string;
-  bodyBytes?:  string; //will be ArrayBuffer in future
+  bodyBytes?: string; //will be ArrayBuffer in future
   // Controls
   timeoutMs?: number;
   followRedirects?: boolean; // default true
@@ -40,7 +40,7 @@ export interface NitroResponse {
 }
 
 export interface NitroFetchClient
-  extends HybridObject<{ ios: 'swift'; android: 'kotlin'; }> {
+  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
   // Client-binded request that uses the env configured at creation.
   request(req: NitroRequest): Promise<NitroResponse>;
   // Start a prefetch for a given request; expects a header `prefetchKey`.
@@ -48,10 +48,17 @@ export interface NitroFetchClient
 }
 
 export interface NitroFetch
-  extends HybridObject<{ ios: 'swift'; android: 'kotlin'; }> {
+  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
   // Create a client bound to a given environment (e.g., cache dir).
   createClient(): NitroFetchClient;
 
   // Optional future: global abort/teardown
   // shutdown(): void;
 }
+
+export interface NativeStorage
+  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
+  getString(key: string): string;
+  setString(key: string, value: string): void;
+  removeString(key: string): void;
+}

package/src/NitroInstances.ts

@@ -1,8 +1,12 @@
 import { NitroModules } from 'react-native-nitro-modules';
-import type { NitroFetch as NitroFetchType } from './NitroFetch.nitro';
+import type {
+  NitroFetch as NitroFetchType,
+  NativeStorage as NativeStorageType,
+} from './NitroFetch.nitro';
 
 // Create singletons once per JS runtime
 export const NitroFetch: NitroFetchType =
   NitroModules.createHybridObject<NitroFetchType>('NitroFetch');
 
-
+export const NativeStorage: NativeStorageType =
+  NitroModules.createHybridObject<NativeStorageType>('NativeStorage');