@chilkat/react-native 11.6.1

package/cpp/runtime/ChilkatError.hpp

@@ -0,0 +1,66 @@
+// ChilkatError.hpp -- hand-maintained (not generated).
+// The exception every generated member throws when a Chilkat call fails, and the
+// "reason line" rule that turns Chilkat's LastErrorText into a one-line message.
+// ReactNativeGen_DESIGN.md §3.4.
+//
+// Nitro turns a std::exception thrown by a synchronous member into a JS Error whose
+// message is "<Class>.<member>(...): <what()>", so what() is the bare reason.  For the
+// Promise-returning twins (AsyncCall.hpp) the rejection message is prefixed here.
+#pragma once
+
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::chilkat {
+
+class ChilkatError : public std::runtime_error {
+public:
+  ChilkatError(const std::string& className, const std::string& methodName, const std::string& lastErrorText)
+      : std::runtime_error(reasonLine(lastErrorText)), _className(className), _methodName(methodName),
+        _lastErrorText(lastErrorText) {}
+
+  const std::string& className() const { return _className; }
+  const std::string& methodName() const { return _methodName; }
+  const std::string& lastErrorText() const { return _lastErrorText; }
+
+  // The last non-empty, non-structural line of a Chilkat log (the same rule as the Rust
+  // and Dart wrappers): section headers ("Foo:"), section ends ("--Foo"), braces and the
+  // bare "Failed." are skipped.  Falls back to "see lastErrorText".
+  static std::string reasonLine(const std::string& log) {
+    std::vector<std::string> lines;
+    std::string cur;
+    for (char c : log) {
+      if (c == '\n') { lines.push_back(cur); cur.clear(); }
+      else if (c != '\r') cur.push_back(c);
+    }
+    if (!cur.empty()) lines.push_back(cur);
+    for (auto it = lines.rbegin(); it != lines.rend(); ++it) {
+      std::string s = trim(*it);
+      if (s.empty()) continue;
+      if (s == "ChilkatLog:" || s == "Failed." || s == "Failed" || s == "Success." || s == "{" || s == "}") continue;
+      if (s.size() >= 2 && s[0] == '-' && s[1] == '-') continue;   // "--ChilkatLog", "--QuickGetStr"
+      if (s.back() == ':') continue;                                // "QuickGetStr:" section start
+      if (s.rfind("DllDate:", 0) == 0 || s.rfind("ChilkatVersion:", 0) == 0 || s.rfind("UnlockPrefix:", 0) == 0 ||
+          s.rfind("UnlockStatus:", 0) == 0 || s.rfind("Architecture:", 0) == 0 || s.rfind("Language:", 0) == 0 ||
+          s.rfind("VerboseLogging:", 0) == 0)
+        continue;
+      return s;
+    }
+    return "see lastErrorText";
+  }
+
+private:
+  static std::string trim(const std::string& s) {
+    size_t b = 0, e = s.size();
+    while (b < e && (s[b] == ' ' || s[b] == '\t')) b++;
+    while (e > b && (s[e - 1] == ' ' || s[e - 1] == '\t')) e--;
+    return s.substr(b, e - b);
+  }
+
+  std::string _className;
+  std::string _methodName;
+  std::string _lastErrorText;
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/runtime/ChilkatObject.hpp

@@ -0,0 +1,219 @@
+// ChilkatObject.hpp -- hand-maintained (not generated).
+// The per-object runtime every generated Hybrid<Class> mixes in: ownership of the Chilkat
+// C++ object, the dispose / busy guards (ReactNativeGen_DESIGN.md §3.3, §5.2), the event
+// state (§6) and the small conversion helpers the generated bodies call.
+#pragma once
+
+#include "ChilkatError.hpp"
+#include <CkBaseProgress.h>
+#include <CkString.h>
+#include <atomic>
+#include <cmath>
+#include <cstdint>
+#include <functional>
+#include <limits>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <stdexcept>
+#include <string>
+
+namespace margelo::nitro::chilkat {
+
+// ---- Events (§6) ------------------------------------------------------------
+
+// Shared between a HybridObject and the CkBaseProgress adapter installed on its Chilkat
+// object.  Callbacks are read under the mutex by the thread running the Chilkat method
+// and written by the JS thread; Nitro schedules the JS function itself on the JS thread.
+struct EventState {
+  std::mutex mutex;
+  std::optional<std::function<void(double)>> onPercentDone;
+  std::optional<std::function<void(const std::string&, const std::string&)>> onProgressInfo;
+  std::atomic<bool> abortRequested{false};
+
+  void percentDone(int pct) {
+    std::optional<std::function<void(double)>> cb;
+    { std::lock_guard<std::mutex> lock(mutex); cb = onPercentDone; }
+    if (cb.has_value()) (*cb)(static_cast<double>(pct));
+  }
+  void progressInfo(const char* name, const char* value) {
+    std::optional<std::function<void(const std::string&, const std::string&)>> cb;
+    { std::lock_guard<std::mutex> lock(mutex); cb = onProgressInfo; }
+    if (cb.has_value()) (*cb)(std::string(name ? name : ""), std::string(value ? value : ""));
+  }
+};
+
+// ---- Busy guard (§5.2) -------------------------------------------------------
+
+// The non-template face of ChilkatObject<Ck>, so AsyncCall can mark object arguments of
+// any class busy while a Promise-returning twin runs.
+class ChilkatBusy {
+public:
+  virtual ~ChilkatBusy() = default;
+  // Marks the object busy with `what` ("Http.quickGetStrAsync"); false if it already was.
+  bool markBusy(const char* what) {
+    const char* expected = nullptr;
+    return _busyWith.compare_exchange_strong(expected, what);
+  }
+  void clearBusy() { _busyWith.store(nullptr); }
+  const char* busyWith() const { return _busyWith.load(); }
+  virtual const char* chilkatClassName() const = 0;
+
+protected:
+  std::atomic<const char*> _busyWith{nullptr};
+};
+
+// ---- The object ---------------------------------------------------------------
+
+template <typename Ck>
+class ChilkatObject : public ChilkatBusy {
+public:
+  // `owned` was created by Ck::createNew2(PROGLANG_REACT_NATIVE) or returned by a Chilkat
+  // method (heap-allocated, ours to delete).
+  ChilkatObject(const char* className, Ck* owned) : _className(className), _ck(owned) {
+    if (!_ck) throw std::runtime_error(std::string(className) + ": the native Chilkat object could not be created");
+    _ck->put_Utf8(true);
+  }
+  ~ChilkatObject() override {
+    // The Chilkat object goes first: it may still point at the progress adapter.
+    _ck.reset();
+    _progress.reset();
+  }
+  ChilkatObject(const ChilkatObject&) = delete;
+  ChilkatObject& operator=(const ChilkatObject&) = delete;
+
+  const char* chilkatClassName() const override { return _className; }
+
+  // The Chilkat object.  Throws after dispose().  Does not check the busy flag: the
+  // generated *_impl bodies run while the object is (deliberately) busy.
+  Ck& ck() {
+    if (!_ck) throw std::runtime_error(std::string(_className) + " has been disposed");
+    return *_ck;
+  }
+
+  // Start of every public synchronous member: not disposed, not busy.  A synchronous
+  // call also clears a stale abort() request (nothing was pending, so it meant nothing).
+  void beginCall() {
+    if (!_ck) throw std::runtime_error(std::string(_className) + " has been disposed");
+    const char* b = _busyWith.load();
+    if (b) throw std::runtime_error(std::string(_className) + " is busy (" + b + " in progress)");
+    if (_ev) _ev->abortRequested.store(false);
+  }
+
+  // dispose(): release the Chilkat object now.  Refused while an async call is running.
+  void disposeChilkat() {
+    const char* b = _busyWith.load();
+    if (b) throw std::runtime_error(std::string(_className) + " is busy (" + b + " in progress) and cannot be disposed");
+    _ck.reset();
+    _progress.reset();
+  }
+  bool isDisposed() const { return !_ck; }
+
+  // The exception for a failed call: LastErrorText is read now, before the next call
+  // overwrites it.
+  ChilkatError fail(const char* method) {
+    CkString s;
+    if (_ck) _ck->get_LastErrorText(s);
+    const char* t = s.getUtf8();
+    return ChilkatError(_className, method, t ? t : "");
+  }
+
+  // ---- events (event-capable classes only) ----
+  // The generated constructor installs the adapter (ProgressAdapter.hpp) once.
+  template <typename Adapter>
+  void installProgress() {
+    _ev = std::make_shared<EventState>();
+    auto adapter = std::make_unique<Adapter>(_ev);
+    _ck->put_EventCallbackObject(adapter.get());
+    _progress = std::move(adapter);
+  }
+  const std::shared_ptr<EventState>& events() const { return _ev; }
+
+  void requestAbort() { if (_ev) _ev->abortRequested.store(true); }
+  void clearAbort() { if (_ev) _ev->abortRequested.store(false); }
+
+  std::optional<std::function<void(double)>> getOnPercentDoneCb() {
+    std::lock_guard<std::mutex> lock(_ev->mutex);
+    return _ev->onPercentDone;
+  }
+  void setOnPercentDoneCb(const std::optional<std::function<void(double)>>& cb) {
+    std::lock_guard<std::mutex> lock(_ev->mutex);
+    _ev->onPercentDone = cb;
+  }
+  std::optional<std::function<void(const std::string&, const std::string&)>> getOnProgressInfoCb() {
+    std::lock_guard<std::mutex> lock(_ev->mutex);
+    return _ev->onProgressInfo;
+  }
+  void setOnProgressInfoCb(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) {
+    std::lock_guard<std::mutex> lock(_ev->mutex);
+    _ev->onProgressInfo = cb;
+  }
+
+protected:
+  const char* _className;
+  std::shared_ptr<EventState> _ev;               // null for the 59 non-event classes
+  std::unique_ptr<CkBaseProgress> _progress;     // declared before _ck: destroyed after it
+  std::unique_ptr<Ck> _ck;
+};
+
+// ---- Conversion helpers used by the generated bodies -------------------------------
+// In their own namespace (`rt::`) so that a Chilkat argument name can never shadow them.
+namespace rt {
+
+// Chilkat takes NUL-terminated UTF-8; an interior NUL would silently truncate.
+inline void checkNoNul(const std::string& s, const char* argName) {
+  if (s.find('\0') != std::string::npos)
+    throw std::runtime_error(std::string("argument '") + argName + "' contains a NUL character");
+}
+
+inline void checkFinite(double v, const char* argName) {
+  if (!std::isfinite(v)) throw std::runtime_error(std::string("argument '") + argName + "' is not a finite number");
+}
+
+inline int toInt(double v, const char* argName) {
+  checkFinite(v, argName);
+  if (v < static_cast<double>(std::numeric_limits<int>::min()) || v > static_cast<double>(std::numeric_limits<int>::max()))
+    throw std::runtime_error(std::string("argument '") + argName + "' is out of range for a 32-bit integer");
+  return static_cast<int>(v);
+}
+
+inline unsigned long toULong(double v, const char* argName) {
+  checkFinite(v, argName);
+  if (v < 0 || v > static_cast<double>(std::numeric_limits<unsigned long>::max()))
+    throw std::runtime_error(std::string("argument '") + argName + "' is out of range for an unsigned integer");
+  return static_cast<unsigned long>(v);
+}
+
+inline __int64 toInt64(double v, const char* argName) {
+  checkFinite(v, argName);
+  return static_cast<__int64>(v);   // exact up to 2^53 (documented)
+}
+
+inline int sizeToInt(size_t n, const char* argName) {
+  if (n > static_cast<size_t>(std::numeric_limits<int>::max()))
+    throw std::runtime_error(std::string("argument '") + argName + "' is too large (more than 2 GB)");
+  return static_cast<int>(n);
+}
+
+inline double toDouble(double v, const char* argName) {
+  checkFinite(v, argName);
+  return v;
+}
+
+// CkString -> std::string (UTF-8; the objects are created with put_Utf8(true)).
+inline std::string stdString(const CkString& s) {
+  const char* p = s.getUtf8();
+  return p ? std::string(p) : std::string();
+}
+
+// The implementation object behind a HybridObject argument (nitrogen types arguments as
+// the spec class).  Throws when the argument is not one of ours (or was disposed).
+template <typename Impl, typename Spec>
+inline Impl& implOf(const std::shared_ptr<Spec>& p, const char* argName) {
+  Impl* i = dynamic_cast<Impl*>(p.get());
+  if (!i) throw std::runtime_error(std::string("argument '") + argName + "' is not a Chilkat object of the expected class");
+  return *i;
+}
+
+} // namespace rt
+} // namespace margelo::nitro::chilkat

package/cpp/runtime/ProgLang.hpp

@@ -0,0 +1,9 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Chilkat's programming-language id for React Native (ReactNativeGen_DESIGN.md §3.3), passed to
+// Ck<Class>::createNew2().  The library's language table must contain the same value.
+#pragma once
+
+namespace margelo::nitro::chilkat {
+constexpr int PROGLANG_REACT_NATIVE = 25;
+constexpr const char* CHILKAT_RN_VERSION = "11.6.1";
+} // namespace margelo::nitro::chilkat

package/cpp/runtime/ProgressAdapter.hpp

@@ -0,0 +1,43 @@
+// ProgressAdapter.hpp -- hand-maintained (not generated).
+// The CkBaseProgress subclass installed on every event-capable Chilkat object.  It runs on
+// whatever thread executes the Chilkat method (the JS thread for a synchronous call, our
+// worker thread for an xxxAsync twin), forwards PercentDone / ProgressInfo to the JS
+// callbacks held in EventState (Nitro schedules them on the JS thread), and answers
+// AbortCheck / PercentDone's abort flag from abort().  ReactNativeGen_DESIGN.md §6.
+//
+// TProgress is CkBaseProgress for most classes, or the class-specific subclass a few
+// classes require (CkHttpProgress, CkFtp2Progress, CkMailManProgress, CkSFtpProgress,
+// CkTarProgress, CkZipProgress); the generated constructor picks it from the header's
+// put_EventCallbackObject signature.  Class-specific events on those subclasses keep
+// their empty default implementations (permanently out of scope).
+#pragma once
+
+#include "ChilkatObject.hpp"
+#include <memory>
+
+namespace margelo::nitro::chilkat {
+
+template <typename TProgress>
+class ProgressAdapter final : public TProgress {
+public:
+  explicit ProgressAdapter(std::shared_ptr<EventState> ev) : _ev(std::move(ev)) {}
+
+  using TProgress::AbortCheck;    // keep the bool-returning overloads visible
+  using TProgress::PercentDone;
+
+  void AbortCheck(bool* abort) override {
+    if (abort) *abort = _ev->abortRequested.load();
+  }
+  void PercentDone(int pctDone, bool* abort) override {
+    _ev->percentDone(pctDone);
+    if (abort) *abort = _ev->abortRequested.load();
+  }
+  void ProgressInfo(const char* name, const char* value) override {
+    _ev->progressInfo(name, value);
+  }
+
+private:
+  std::shared_ptr<EventState> _ev;
+};
+
+} // namespace margelo::nitro::chilkat

package/nitro.json

@@ -0,0 +1,113 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": ["chilkat"],
+  "ios": {
+    "iosModuleName": "ChilkatRN"
+  },
+  "android": {
+    "androidNamespace": ["chilkat"],
+    "androidCxxLibName": "ChilkatRN"
+  },
+  "autolinking": {
+    "Ai": { "all": { "language": "c++", "implementationClassName": "HybridAi" } },
+    "Asn": { "all": { "language": "c++", "implementationClassName": "HybridAsn" } },
+    "AuthAws": { "all": { "language": "c++", "implementationClassName": "HybridAuthAws" } },
+    "AuthAzureSAS": { "all": { "language": "c++", "implementationClassName": "HybridAuthAzureSAS" } },
+    "AuthAzureStorage": { "all": { "language": "c++", "implementationClassName": "HybridAuthAzureStorage" } },
+    "AuthGoogle": { "all": { "language": "c++", "implementationClassName": "HybridAuthGoogle" } },
+    "BinData": { "all": { "language": "c++", "implementationClassName": "HybridBinData" } },
+    "Bz2": { "all": { "language": "c++", "implementationClassName": "HybridBz2" } },
+    "Cache": { "all": { "language": "c++", "implementationClassName": "HybridCache" } },
+    "Cert": { "all": { "language": "c++", "implementationClassName": "HybridCert" } },
+    "CertChain": { "all": { "language": "c++", "implementationClassName": "HybridCertChain" } },
+    "CertStore": { "all": { "language": "c++", "implementationClassName": "HybridCertStore" } },
+    "Charset": { "all": { "language": "c++", "implementationClassName": "HybridCharset" } },
+    "CkDateTime": { "all": { "language": "c++", "implementationClassName": "HybridCkDateTime" } },
+    "CodeSign": { "all": { "language": "c++", "implementationClassName": "HybridCodeSign" } },
+    "Compression": { "all": { "language": "c++", "implementationClassName": "HybridCompression" } },
+    "Crypt2": { "all": { "language": "c++", "implementationClassName": "HybridCrypt2" } },
+    "Csr": { "all": { "language": "c++", "implementationClassName": "HybridCsr" } },
+    "Csv": { "all": { "language": "c++", "implementationClassName": "HybridCsv" } },
+    "Dh": { "all": { "language": "c++", "implementationClassName": "HybridDh" } },
+    "DirTree": { "all": { "language": "c++", "implementationClassName": "HybridDirTree" } },
+    "Dkim": { "all": { "language": "c++", "implementationClassName": "HybridDkim" } },
+    "Dns": { "all": { "language": "c++", "implementationClassName": "HybridDns" } },
+    "Dsa": { "all": { "language": "c++", "implementationClassName": "HybridDsa" } },
+    "DtObj": { "all": { "language": "c++", "implementationClassName": "HybridDtObj" } },
+    "Ecc": { "all": { "language": "c++", "implementationClassName": "HybridEcc" } },
+    "EdDSA": { "all": { "language": "c++", "implementationClassName": "HybridEdDSA" } },
+    "Email": { "all": { "language": "c++", "implementationClassName": "HybridEmail" } },
+    "EmailBundle": { "all": { "language": "c++", "implementationClassName": "HybridEmailBundle" } },
+    "FileAccess": { "all": { "language": "c++", "implementationClassName": "HybridFileAccess" } },
+    "Ftp2": { "all": { "language": "c++", "implementationClassName": "HybridFtp2" } },
+    "Global": { "all": { "language": "c++", "implementationClassName": "HybridGlobal" } },
+    "Gzip": { "all": { "language": "c++", "implementationClassName": "HybridGzip" } },
+    "Hashtable": { "all": { "language": "c++", "implementationClassName": "HybridHashtable" } },
+    "HtmlToText": { "all": { "language": "c++", "implementationClassName": "HybridHtmlToText" } },
+    "HtmlToXml": { "all": { "language": "c++", "implementationClassName": "HybridHtmlToXml" } },
+    "Http": { "all": { "language": "c++", "implementationClassName": "HybridHttp" } },
+    "HttpCurl": { "all": { "language": "c++", "implementationClassName": "HybridHttpCurl" } },
+    "HttpRequest": { "all": { "language": "c++", "implementationClassName": "HybridHttpRequest" } },
+    "HttpResponse": { "all": { "language": "c++", "implementationClassName": "HybridHttpResponse" } },
+    "Imap": { "all": { "language": "c++", "implementationClassName": "HybridImap" } },
+    "JavaKeyStore": { "all": { "language": "c++", "implementationClassName": "HybridJavaKeyStore" } },
+    "Js": { "all": { "language": "c++", "implementationClassName": "HybridJs" } },
+    "JsonArray": { "all": { "language": "c++", "implementationClassName": "HybridJsonArray" } },
+    "JsonObject": { "all": { "language": "c++", "implementationClassName": "HybridJsonObject" } },
+    "Jwe": { "all": { "language": "c++", "implementationClassName": "HybridJwe" } },
+    "Jws": { "all": { "language": "c++", "implementationClassName": "HybridJws" } },
+    "Jwt": { "all": { "language": "c++", "implementationClassName": "HybridJwt" } },
+    "Log": { "all": { "language": "c++", "implementationClassName": "HybridLog" } },
+    "MailMan": { "all": { "language": "c++", "implementationClassName": "HybridMailMan" } },
+    "Mailboxes": { "all": { "language": "c++", "implementationClassName": "HybridMailboxes" } },
+    "Mcp": { "all": { "language": "c++", "implementationClassName": "HybridMcp" } },
+    "MessageSet": { "all": { "language": "c++", "implementationClassName": "HybridMessageSet" } },
+    "Mht": { "all": { "language": "c++", "implementationClassName": "HybridMht" } },
+    "Mime": { "all": { "language": "c++", "implementationClassName": "HybridMime" } },
+    "Ntlm": { "all": { "language": "c++", "implementationClassName": "HybridNtlm" } },
+    "OAuth1": { "all": { "language": "c++", "implementationClassName": "HybridOAuth1" } },
+    "OAuth2": { "all": { "language": "c++", "implementationClassName": "HybridOAuth2" } },
+    "Pdf": { "all": { "language": "c++", "implementationClassName": "HybridPdf" } },
+    "Pem": { "all": { "language": "c++", "implementationClassName": "HybridPem" } },
+    "Pfx": { "all": { "language": "c++", "implementationClassName": "HybridPfx" } },
+    "Pkcs11": { "all": { "language": "c++", "implementationClassName": "HybridPkcs11" } },
+    "PrivateKey": { "all": { "language": "c++", "implementationClassName": "HybridPrivateKey" } },
+    "Prng": { "all": { "language": "c++", "implementationClassName": "HybridPrng" } },
+    "PublicKey": { "all": { "language": "c++", "implementationClassName": "HybridPublicKey" } },
+    "Rest": { "all": { "language": "c++", "implementationClassName": "HybridRest" } },
+    "Rsa": { "all": { "language": "c++", "implementationClassName": "HybridRsa" } },
+    "SCard": { "all": { "language": "c++", "implementationClassName": "HybridSCard" } },
+    "SFtp": { "all": { "language": "c++", "implementationClassName": "HybridSFtp" } },
+    "SFtpDir": { "all": { "language": "c++", "implementationClassName": "HybridSFtpDir" } },
+    "SFtpFile": { "all": { "language": "c++", "implementationClassName": "HybridSFtpFile" } },
+    "ScMinidriver": { "all": { "language": "c++", "implementationClassName": "HybridScMinidriver" } },
+    "Scp": { "all": { "language": "c++", "implementationClassName": "HybridScp" } },
+    "Secrets": { "all": { "language": "c++", "implementationClassName": "HybridSecrets" } },
+    "SecureString": { "all": { "language": "c++", "implementationClassName": "HybridSecureString" } },
+    "ServerSentEvent": { "all": { "language": "c++", "implementationClassName": "HybridServerSentEvent" } },
+    "Socket": { "all": { "language": "c++", "implementationClassName": "HybridSocket" } },
+    "Spider": { "all": { "language": "c++", "implementationClassName": "HybridSpider" } },
+    "Ssh": { "all": { "language": "c++", "implementationClassName": "HybridSsh" } },
+    "SshKey": { "all": { "language": "c++", "implementationClassName": "HybridSshKey" } },
+    "SshTunnel": { "all": { "language": "c++", "implementationClassName": "HybridSshTunnel" } },
+    "Stream": { "all": { "language": "c++", "implementationClassName": "HybridStream" } },
+    "StringArray": { "all": { "language": "c++", "implementationClassName": "HybridStringArray" } },
+    "StringBuilder": { "all": { "language": "c++", "implementationClassName": "HybridStringBuilder" } },
+    "StringTable": { "all": { "language": "c++", "implementationClassName": "HybridStringTable" } },
+    "Tar": { "all": { "language": "c++", "implementationClassName": "HybridTar" } },
+    "TrustedRoots": { "all": { "language": "c++", "implementationClassName": "HybridTrustedRoots" } },
+    "UnixCompress": { "all": { "language": "c++", "implementationClassName": "HybridUnixCompress" } },
+    "Upload": { "all": { "language": "c++", "implementationClassName": "HybridUpload" } },
+    "Url": { "all": { "language": "c++", "implementationClassName": "HybridUrl" } },
+    "WebSocket": { "all": { "language": "c++", "implementationClassName": "HybridWebSocket" } },
+    "Xml": { "all": { "language": "c++", "implementationClassName": "HybridXml" } },
+    "XmlCertVault": { "all": { "language": "c++", "implementationClassName": "HybridXmlCertVault" } },
+    "XmlDSig": { "all": { "language": "c++", "implementationClassName": "HybridXmlDSig" } },
+    "XmlDSigGen": { "all": { "language": "c++", "implementationClassName": "HybridXmlDSigGen" } },
+    "Xmp": { "all": { "language": "c++", "implementationClassName": "HybridXmp" } },
+    "Zip": { "all": { "language": "c++", "implementationClassName": "HybridZip" } },
+    "ZipCrc": { "all": { "language": "c++", "implementationClassName": "HybridZipCrc" } },
+    "ZipEntry": { "all": { "language": "c++", "implementationClassName": "HybridZipEntry" } }
+  },
+  "ignorePaths": ["node_modules", "example"]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/android/ChilkatRN+autolinking.cmake

@@ -0,0 +1,179 @@
+#
+# ChilkatRN+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/ChilkatRN+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_CHILKATRN_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  ChilkatRN PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/ChilkatRNOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridAiSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridAsnSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridAuthAwsSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridAuthAzureSASSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridAuthAzureStorageSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridAuthGoogleSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridBinDataSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridBz2Spec.cpp
+  ../nitrogen/generated/shared/c++/HybridCacheSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCertSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCertChainSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCertStoreSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCharsetSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCkDateTimeSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCodeSignSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCompressionSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCrypt2Spec.cpp
+  ../nitrogen/generated/shared/c++/HybridCsrSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCsvSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridDhSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridDirTreeSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridDkimSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridDnsSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridDsaSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridDtObjSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridEccSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridEdDSASpec.cpp
+  ../nitrogen/generated/shared/c++/HybridEmailSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridEmailBundleSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridFileAccessSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridFtp2Spec.cpp
+  ../nitrogen/generated/shared/c++/HybridGlobalSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridGzipSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridHashtableSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridHtmlToTextSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridHtmlToXmlSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridHttpSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridHttpCurlSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridHttpRequestSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridHttpResponseSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridImapSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridJavaKeyStoreSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridJsSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridJsonArraySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridJsonObjectSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridJweSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridJwsSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridJwtSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridLogSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMailboxesSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMailManSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMcpSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMessageSetSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMhtSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMimeSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridNtlmSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridOAuth1Spec.cpp
+  ../nitrogen/generated/shared/c++/HybridOAuth2Spec.cpp
+  ../nitrogen/generated/shared/c++/HybridPdfSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridPemSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridPfxSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridPkcs11Spec.cpp
+  ../nitrogen/generated/shared/c++/HybridPrivateKeySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridPrngSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridPublicKeySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridRestSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridRsaSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSCardSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridScMinidriverSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridScpSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSecretsSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSecureStringSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridServerSentEventSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSFtpSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSFtpDirSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSFtpFileSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSocketSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSpiderSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSshSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSshKeySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSshTunnelSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridStreamSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridStringArraySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridStringBuilderSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridStringTableSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridTarSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridTrustedRootsSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridUnixCompressSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridUploadSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridUrlSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridWebSocketSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridXmlSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridXmlCertVaultSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridXmlDSigSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridXmlDSigGenSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridXmpSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridZipSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridZipCrcSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridZipEntrySpec.cpp
+  # Android-specific Nitrogen C++ sources
+  
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  ChilkatRN PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        ChilkatRN
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        ChilkatRN
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        ChilkatRN
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()