@chilkat/react-native 11.6.1

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+Releases follow the Chilkat library version; notes at https://www.cknotes.com/category/release-notes/
+
+## 11.6.1
+- First generated package: TypeScript specs for 99 classes, nitrogen output.

package/ChilkatRN.podspec

@@ -0,0 +1,44 @@
+# ChilkatRN.podspec -- hand-maintained (not generated).  ReactNativeGen_DESIGN.md §7.3.
+#
+# The pod is the generated C++ (cpp/**), nitrogen's specs and iOS autolinking files, and the
+# prebuilt Chilkat library as an xcframework that scripts/fetch-chilkat.js places in
+# native/ios/ at `pod install` time (prepare_command).
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ChilkatRN"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = { :type => "Commercial", :file => "LICENSE" }
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  # Distributed through npm; CocoaPods still wants a source.
+  s.source       = { :git => "https://www.chilkatsoft.com/", :tag => "#{s.version}" }
+
+  # Download (or reuse) the prebuilt Chilkat library: native/ios/Chilkat.xcframework + include/.
+  # Override with CHILKAT_RN_LIB_DIR or "chilkat": { "libDir": ... } in the app's package.json.
+  s.prepare_command = "node scripts/fetch-chilkat.js ios"
+
+  s.source_files = [
+    # The generated HybridObject implementations and the hand-maintained runtime
+    "cpp/**/*.{hpp,cpp}",
+  ]
+  s.vendored_frameworks = "native/ios/Chilkat.xcframework"
+  s.preserve_paths = ["native/ios/**/*", "scripts/**/*", "chilkat-checksums.json"]
+
+  # Set before add_nitrogen_files so its (C++20, Swift interop) settings merge on top.
+  s.pod_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => '"$(PODS_TARGET_SRCROOT)/native/ios/include" "$(PODS_TARGET_SRCROOT)/cpp"',
+  }
+
+  load 'nitrogen/generated/ios/ChilkatRN+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,254 @@
+========================================================================
+                        Chilkat Software License
+========================================================================
+
+PLEASE READ THIS AGREEMENT BEFORE OPENING THIS SOFTWARE PACKAGE. IF YOU
+OPEN THIS PACKAGE OR KEEP IT FOR MORE THAN THIRTY (30) DAYS, YOU ACCEPT
+ALL THE TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE TO
+THESE TERMS AND CONDITIONS, DO NOT OPEN THIS SOFTWARE PACKAGE. YOU MAY
+ONLY UNLOCK AND/OR USE THE SOFTWARE FOR WHICH YOU HAVE A PAID-UP LICENSE
+OR FOR WHICH YOU HAVE LEGALLY RECEIVED AN UNLOCK KEY.
+
+(1) DEFINITION OF TERMS
+
+"Documentation": any explanatory written or on-line material including,
+but not limited to, user guides, reference manuals and HTML files.
+
+"Licensee": shall refer to the individual licensee, whether as an
+individual programmer, company, or other organization.
+
+"Software": All material in this distribution including, but not limited
+to, one or more of the following: source code, object code, byte code,
+dynamic-link libraries, shared libraries, static libraries, header
+files, executables, scripts, sample programs, utility programs,
+makefiles and Documentation.
+
+"Licensed Software": the Software for which Licensee has paid the
+applicable license fee and received an authorized unlock key.
+
+"Software Application Programming Interface ("API")": the set of access
+methods, whether provided by Chilkat Software, third parties, or
+developed by Licensee, through which the programmatic services provided
+by the Licensed Software are made available.
+
+"Application" or "Your Application" means a software application that
+You develop which incorporates all or parts of the Licensed Software.
+
+The Licensed Software contains certain runtime libraries and files
+intended for duplication and distribution by Licensee within End User
+Software Products to the user(s) of the End User Software Product(s)
+(the "Redistributable Components"). The Redistributable Components are
+those files specifically designated as being distributable as part of
+the Licensed Software.
+
+SPECIAL LIMITED TERM EVALUATION LICENSE
+
+If Licensee has downloaded a copy of the Software for evaluation
+purposes, Chilkat Software, Inc. ("Chilkat") grants to Licensee, subject
+to the terms of this License Agreement (excluding Section 3, under which
+Licensee has no rights) a non-exclusive, non-transferable,
+non-concurrent limited internal use license for evaluation purposes
+only. This license is for a period of thirty (30) days, commencing from
+Licensee's initial downloading date, to evaluate the Software. If the
+Software is acceptable, Licensee agrees to promptly notify his Chilkat
+Sales Representative. Otherwise, Licensee shall immediately cease any
+further use of the Software.
+
+(2) GENERAL
+
+The Software is owned by Chilkat Software, Inc. ("Chilkat") and is
+protected by U.S. copyright laws and other laws and by international
+treaties. It is intended for use by a software programmer who has
+experience using development tools and class libraries.
+
+(3) DEVELOPER LICENSE GRANTS
+
+The specific license level selected by you at the time of purchase or
+most recent upgrade determines whether the license applies to (a) a
+single named developer, (b) a small group of up to 4 developers, or (c)
+a team of up to 8 developers.
+
+Subject to the terms and conditions of this Agreement, Chilkat grants to
+Licensee the perpetual, non-exclusive, non-transferable, royalty-free
+license to integrate the Licensed Software into Your Applications and to
+distribute such Licensed Software in connection with said Applications,
+provided that (a) said Applications do not in any way compete with the
+Licensed Software, or provide substantially the same functionality as
+the Licensed Software, or expose the functionality of the Licensed
+Software through a programmable interface; (b) each of Your Applications
+developed using Licensed Software is designed for end users, rather than
+for developers who would be able to build other software that would
+compete with the Licensed Software, and (c) You do not permit further
+distribution of the Licensed Software by Your end users.
+
+For each License Key provided to You by Chilkat, depending on the
+specific license level selected by you at the time of purchase or most
+recent upgrade, You are granted a nonexclusive License to make the
+Licensed Software and/or the License Key(s) available to the specified
+number of Your named developers. Should the number of named developers
+with access to the Licensed Software and/or the License Key(s) ever
+exceed the number indicated at the time of original purchase or most
+recent upgrade, You agree to inform Chilkat of such change and to
+upgrade Your License accordingly by paying an upgrade fee to Chilkat in
+a timely manner.
+
+A "1 Developer License" which may also be referred to as "Single
+Developer License" means that only one named individual developer
+employed by You may be given access to the Licensed Software and/or the
+License Key(s) for the sole purpose of developing and maintaining Your
+Applications. For as long as this specific individual developer is
+employed or engaged by You in any capacity whatsoever whereby he or she
+may access the Licensed Software and/or the License Key(s), no other
+developer may be given access to the Licensed Software and/or the
+License Key(s). Should said individual developer leave Your employ and
+cease any professional association with You, or otherwise relinquish any
+and all access the Licensed Software and/or the License Key(s), a new
+named individual developer may then take his or her place and be given
+access to the Licensed Software and/or the License Key(s).
+
+A "Team License" or "Small Group License" is equivalent to a specified
+number of single developer licenses. For example a "4 Developers Small
+Group License" is equivalent to 4 single developer licenses. The number
+of developers in a team identifies the maximum number of the named
+individual developers employed by You who may be given access to the
+Licensed Software and/or the License Key(s) for the sole purpose of
+developing and maintaining Your Applications. For as long as the allowed
+maximum number of named individual developers are employed or engaged by
+You in any capacity whatsoever whereby these named individual developers
+may access the Licensed Software and/or the License Key(s), no other
+developer may be given access to the Licensed Software and/or the
+License Key(s). Should any single named individual developer leave Your
+employ and cease any professional association with You, or otherwise
+relinquish any and all access the Licensed Software and/or the License
+Key(s), a new named individual developer may then take his or her place
+and be given access to the Licensed Software and/or the License Key(s),
+whereby the total number of said named developers would not exceed the
+licensed team size.
+
+Licensee has no rights to use the Licensed Software beyond those
+specifically granted in this section.
+
+(4) LICENSE RESTRICTIONS
+
+EXPORT CONTROLS: If the Software is for use outside the United States of
+America, Licensee agrees to comply with all relevant regulations of the
+United States Department of Commerce and with the United States Export
+Administration Act to insure that the Software is not exported in
+violation of United States law.
+
+Notwithstanding any provisions in this Agreement to the contrary,
+Licensee may not distribute any portion of the Software other than the
+Redistributable Components.
+
+In addition, Licensee may not decompile, disassemble, or reverse
+engineer any object code form of any portion of the Software.
+
+(5) TITLE
+
+Licensee acknowledges and agrees that all right, title and interest in
+and to the Software, including all intellectual property rights therein,
+are the property of Chilkat, subject only to the licenses granted to
+Licensee under this Agreement. This Agreement is not a sale and does not
+transfer to the Licensee any title or ownership in or to the Software or
+any patent, copyright, trade secret, trade name, trademark or other
+proprietary or intellectual property rights related thereto.
+
+(6) NON-TRANSFERABILITY
+
+Except for Licensee's rights to distribute the Redistributable
+Components, Licensee may not rent, transfer, assign, sublicense or grant
+any rights in the Software, in full or in part, to any other person or
+entity without Chilkat's written consent, except that this agreement may
+be assigned to a successor of Licensee in the case that all or
+substantially all of the assets or equity of Licensee are acquired by
+the successor.
+
+(7) LIMITED WARRANTIES
+
+Chilkat warrants to Licensee that the Licensed Software will
+substantially perform the functions described in the Documentation for a
+period of thirty (30) days after the date of delivery of the Licensed
+Software to Licensee. Chilkat's sole and exclusive obligation, and
+Licensee's sole and exclusive remedy, under this warranty is limited to
+Chilkat's using reasonable efforts to correct material, documented,
+reproducible defects in the Licensed Software that Licensee describes
+and documents to Chilkat during the thirty (30) day warranty period. In
+the event that Chilkat fails to correct a material, documented,
+reproducible defect during this period, Chilkat may, at Chilkat's
+discretion, replace the defective Licensed Software or refund to
+Licensee the amount that Licensee paid Chilkat for the defective
+Licensed Software and cancel this Agreement and the licenses granted
+herein. In such event, Licensee agrees to return to Chilkat all copies
+of the Licensed Software (including the original).
+
+EXCEPT AS EXPRESSLY SET FORTH ABOVE, CHILKAT EXPRESSLY DISCLAIMS ALL
+OTHER WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE, RESULTS, OR OTHERWISE.
+
+(8) LIMITATION OF LIABILITY
+
+IN NO EVENT SHALL CHILKAT BE LIABLE FOR ANY DIRECT, INDIRECT, PUNITIVE,
+SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES (INCLUDING LOST PROFITS,
+REVENUES, DATA OR OTHER ECONOMIC ADVANTAGE) WHETHER BASED ON CONTRACT,
+TORT, OR ANY OTHER LEGAL THEORY, EVEN IF CHILKAT WAS ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES. NOTWITHSTANDING THE FOREGOING, THE TOTAL
+AMOUNT OF CHILKAT'S LIABILITY TO LICENSEE SHALL BE LIMITED TO THE AMOUNT
+USER PAID FOR THE USE OF THE SOFTWARE, IF ANY.
+
+(9) TERMINATION
+
+Chilkat reserves the right, at its sole discretion, to terminate this
+Agreement upon written notice if Licensee has breached the terms and
+conditions hereof. Licensee may terminate this Agreement at any time by
+ceasing to use the Licensed Software and by destroying all copies of the
+Licensed Software (including the original). Sections 4, 5, 6, 7, 8, 9
+and 10 survive any termination of this Agreement and apply fully to any
+termination. Unless terminated as provided herein by either party, this
+Agreement shall remain in effect. Termination will not affect end user
+licenses of the End User Software Product which contain the
+Redistributable Components which were distributed by Licensee prior to
+termination.
+
+(10) MISCELLANEOUS
+
+Applicable Law and Jurisdiction. This Agreement will be governed by and
+construed in accordance with the laws of the State of Illinois without
+regard to conflict of laws principles and without regard to the 1980
+U.N. Convention on Contracts for the International Sale of Goods. The
+federal and state courts of Illinois shall have exclusive jurisdiction
+and venue to adjudicate any dispute arising out of this Agreement, and
+Licensee expressly consents to (i) the personal jurisdiction of the
+state and federal courts of Illinois, and (ii) service of process being
+effected upon Licensee by registered mail.
+
+Limitation of Actions. No action, regardless of form, may be brought by
+either party more than twelve (12) months after the cause of action has
+arisen. No such claim may be brought unless Chilkat has first been given
+commercially reasonable notice, a full written explanation of all
+pertinent details (including copies of all materials), and a good faith
+opportunity to resolve the matter.
+
+Invalidity and Waiver. Should any provision of this Agreement be held by
+a court of law to be illegal, invalid, or unenforceable, the legality,
+validity, and enforceability of the remaining provisions of this
+Agreement will not be affected or impaired thereby. The failure of any
+party to enforce any of the terms or conditions of this Agreement,
+unless waived in writing, will not constitute a waiver of that party's
+right to enforce each and every term and condition of this Agreement.
+
+U.S. Government Restricted Rights. The Licensed Software is provided
+with Restricted Rights. Use, duplication, or disclosure by the
+Government is subject to restrictions as set forth in subparagraph (c)
+(1) (ii) of The Rights in Technical Data and Computer Software clause at
+DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the Commercial
+Computer Software Restricted Rights at 48 CFR 52.227-19, as applicable.
+Manufacturer is Chilkat Software, Inc., 1719 E Forest Ave, Wheaton,
+Illinois 60187 USA.
+
+LICENSEE ACKNOWLEDGES THAT HE HAS READ THIS AGREEMENT, UNDERSTANDS IT
+AND AGREES TO BE BOUND BY ITS TERMS AND CONDITIONS. LICENSEE FURTHER
+AGREES THAT IT IS THE COMPLETE AND EXCLUSIVE STATEMENT OF THE AGREEMENT
+BETWEEN LICENSEE AND CHILKAT WHICH SUPERSEDES ANY PROPOSAL OR PRIOR OR
+CONTEMPORANEOUS AGREEMENT, ORAL OR WRITTEN, AND ANY OTHER COMMUNICATIONS
+RELATING TO THE SUBJECT MATTER OF THIS AGREEMENT.

package/README.md

@@ -0,0 +1,67 @@
+# @chilkat/react-native
+
+The Chilkat class library for React Native and Expo, as a [Nitro Module](https://nitro.margelo.com):
+HTTP, REST, email (SMTP/POP3/IMAP), FTP, SFTP, SSH, zip, encryption, digital signatures,
+certificates, XML, JSON and more — the same classes Chilkat offers for every other language, written
+once in C++ and exposed to JavaScript/TypeScript with full type declarations and inline docs.
+
+> Status: generated TypeScript specs, nitrogen output and C++ implementations are complete and compile-checked;
+> the native-library download, podspec/Gradle build and example app are next (see
+> `killerApps/ChilkatApi/ReactNativeGen_DESIGN.md`).
+
+## Install
+
+```sh
+npm install @chilkat/react-native react-native-nitro-modules
+cd ios && pod install            # bare React Native (>= 0.76, New Architecture)
+npx expo prebuild                # Expo (development build / EAS Build; Expo Go cannot load native code)
+```
+
+Requirements: React Native 0.76 or newer with the New Architecture (the default), Xcode 16.4+, and
+`react-native-nitro-modules` (installed above). Node must be on the PATH of the shell that runs
+`pod install` or Gradle, because the native build runs `scripts/fetch-chilkat.js`.
+
+The Chilkat native library itself is not in this npm package: `pod install` (iOS) and the Gradle
+build (Android) download `chilkat-rn-ios.tar.gz` / `chilkat-rn-android.tar.gz` for this exact
+version from chilkatdownload.com, verify their SHA-256 against `chilkat-checksums.json`, and unpack
+them under `node_modules/@chilkat/react-native/native/`. A verified copy is reused by later builds.
+
+Offline or custom builds: set the environment variable `CHILKAT_RN_LIB_DIR`, or add
+`"chilkat": { "libDir": "./vendor/chilkat" }` to your app's `package.json`, pointing at a directory
+that holds either the two archives or their unpacked contents (`ios/Chilkat.xcframework`,
+`ios/include`, `android/<abi>/libchilkat.a`, `android/include`). On EAS Build, set the variable as
+a build secret or environment variable.
+
+## Use
+
+```ts
+import { Chilkat, Http, JsonObject } from '@chilkat/react-native'
+
+Chilkat.unlockBundle('Anything for 30-day trial')
+
+const http = new Http()
+http.connectTimeout = 30
+const body = await http.quickGetStrAsync('https://api.example.com/items')   // native worker thread
+
+const json = new JsonObject()
+json.load(body)                          // throws on failure; see json.lastErrorText
+console.log(json.stringOf('items[0].name'))
+```
+
+Every method has a synchronous form. Methods that can take a while (network, files, compression,
+key generation) also have an `...Async` form returning a `Promise` — use those from UI code. While
+an async call is pending, other calls on the same object throw; `abort()` cancels it, and
+`onPercentDone` / `onProgressInfo` report progress.
+
+Binary data is an `ArrayBuffer` in both directions. For a `Uint8Array` view `u8`, pass
+`u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength)`.
+
+## Documentation
+
+Reference: https://www.chilkatsoft.com/refdoc/ · Examples: https://www.example-code.com/ ·
+Support: https://www.chilkatsoft.com/support.asp
+
+## License
+
+See LICENSE (the Chilkat license). Freeware classes work without an unlock code; commercial classes
+run for 30 days with any unlock string.

package/android/CMakeLists.txt

@@ -0,0 +1,60 @@
+# CMakeLists.txt -- hand-maintained (not generated).  ReactNativeGen_DESIGN.md §7.3.
+# libChilkatRN.so = JNI entry point + the 99 generated Hybrid*.cpp + nitrogen's specs, linked with
+# the prebuilt per-ABI Chilkat static library (native/android/<abi>/libchilkat.a).
+project(ChilkatRN)
+cmake_minimum_required(VERSION 3.22)
+
+set(PACKAGE_NAME ChilkatRN)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Where scripts/fetch-chilkat.js unpacked the Chilkat library (passed by build.gradle).
+if(NOT DEFINED CHILKAT_NATIVE_DIR)
+  set(CHILKAT_NATIVE_DIR "${CMAKE_SOURCE_DIR}/../native/android")
+endif()
+
+file(GLOB CHILKAT_HYBRID_SOURCES "${CMAKE_SOURCE_DIR}/../cpp/Hybrid*.cpp")
+
+add_library(${PACKAGE_NAME} SHARED
+  src/main/cpp/cpp-adapter.cpp
+  ${CHILKAT_HYBRID_SOURCES}
+)
+
+# React Native's official C++ flags (RN_SERIALIZABLE_STATE etc.), when available.
+if(DEFINED REACT_ANDROID_DIR AND EXISTS "${REACT_ANDROID_DIR}/../ReactCommon/cmake-utils/react-native-flags.cmake")
+  set(REACT_COMMON_DIR ${REACT_ANDROID_DIR}/../ReactCommon)
+  include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
+  target_compile_reactnative_options(${PACKAGE_NAME} PRIVATE)
+else()
+  target_compile_definitions(${PACKAGE_NAME} PRIVATE RN_SERIALIZABLE_STATE)
+endif()
+
+# Nitrogen's specs, Nitro, fbjni and React Native (adds sources, includes and link libraries).
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/ChilkatRN+autolinking.cmake)
+
+include_directories(
+  "src/main/cpp"
+  "../cpp"
+  "${CHILKAT_NATIVE_DIR}/include"
+)
+
+# The prebuilt Chilkat library for this ABI.  IMPORTED, so configuration succeeds before the
+# fetch task has run (Android Studio sync); the link step needs the file.
+add_library(chilkat STATIC IMPORTED)
+set_target_properties(chilkat PROPERTIES IMPORTED_LOCATION "${CHILKAT_NATIVE_DIR}/${ANDROID_ABI}/libchilkat.a")
+
+find_library(LOG_LIB log)
+
+# Chilkat's symbols stay internal to libChilkatRN.so (--exclude-libs applies to the static
+# archive only; our own and Nitro's symbols keep their default visibility, as Nitro expects).
+# 16 KB page alignment for Android 15+ devices (also set by ANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES
+# on NDK r27+).
+target_link_options(${PACKAGE_NAME} PRIVATE -Wl,--exclude-libs,ALL -Wl,-z,max-page-size=16384)
+
+target_link_libraries(
+  ${PACKAGE_NAME}
+  chilkat        # <-- the Chilkat static library
+  ${LOG_LIB}
+  android
+  z
+)

package/android/build.gradle

@@ -0,0 +1,148 @@
+// build.gradle -- hand-maintained (not generated).  ReactNativeGen_DESIGN.md §7.3.
+// The Android side of @chilkat/react-native: one CMake library, libChilkatRN.so, built from the
+// generated C++ (../cpp) plus nitrogen's specs, statically linked with the prebuilt Chilkat
+// library that scripts/fetch-chilkat.js places in ../native/android/<abi>/libchilkat.a.
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.12.0"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+apply from: "../nitrogen/generated/android/ChilkatRN+autolinking.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["ChilkatRN_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ChilkatRN_" + name]).toInteger()
+}
+
+// Where fetch-chilkat.js puts the library (it also honours CHILKAT_RN_LIB_DIR / chilkat.libDir
+// by copying into this directory, so CMake always looks in one place).
+def chilkatNativeDir = "${project.projectDir}/../native/android"
+
+android {
+  namespace "com.margelo.nitro.chilkat"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared",
+                  "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON",
+                  "-DCHILKAT_NATIVE_DIR=${chilkatNativeDir}"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+      "META-INF",
+      "META-INF/**",
+      "**/libc++_shared.so",
+      "**/libfbjni.so",
+      "**/libjsi.so",
+      "**/libfolly_json.so",
+      "**/libfolly_runtime.so",
+      "**/libglog.so",
+      "**/libhermes.so",
+      "**/libhermes-executor-debug.so",
+      "**/libhermes_executor.so",
+      "**/libreactnative.so",
+      "**/libreactnativejni.so",
+      "**/libturbomodulejsijni.so",
+      "**/libreact_nativemodule_core.so",
+      "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+dependencies {
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation project(":react-native-nitro-modules")
+}
+
+// Fetch (or reuse) the prebuilt Chilkat library before anything native is configured or built.
+tasks.register("fetchChilkat", Exec) {
+  description = "Downloads or verifies the prebuilt Chilkat library for Android (scripts/fetch-chilkat.js)"
+  workingDir "${project.projectDir}/.."
+  def isWindows = System.getProperty("os.name").toLowerCase().contains("windows")
+  commandLine isWindows ? ["cmd", "/c", "node", "scripts/fetch-chilkat.js", "android"]
+                        : ["node", "scripts/fetch-chilkat.js", "android"]
+  outputs.upToDateWhen { false }   // the script is cheap when the library is already present and verified
+}
+preBuild.dependsOn(fetchChilkat)
+tasks.configureEach { task ->
+  if (task.name.startsWith("configureCMake") || task.name.startsWith("buildCMake") || task.name.startsWith("externalNativeBuild")) {
+    task.dependsOn(fetchChilkat)
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+ChilkatRN_kotlinVersion=2.1.20
+ChilkatRN_minSdkVersion=24
+ChilkatRN_targetSdkVersion=36
+ChilkatRN_compileSdkVersion=36
+ChilkatRN_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,12 @@
+// cpp-adapter.cpp -- hand-maintained (not generated).
+// JNI entry point of libChilkatRN.so: registers every Chilkat HybridObject constructor with
+// Nitro (nitrogen's ChilkatRNOnLoad.cpp) when the library is loaded.
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include "ChilkatRNOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::chilkat::registerAllNatives();
+  });
+}

package/android/src/main/java/com/margelo/nitro/chilkat/ChilkatRNPackage.java

@@ -0,0 +1,33 @@
+// ChilkatRNPackage.java -- hand-maintained (not generated).
+// The ReactPackage React Native's autolinking registers for @chilkat/react-native.  It exposes
+// no TurboModules or views: its only job is to load libChilkatRN.so (which registers the
+// Chilkat HybridObjects with Nitro) when the package is instantiated.
+package com.margelo.nitro.chilkat;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.BaseReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+
+import java.util.HashMap;
+
+public class ChilkatRNPackage extends BaseReactPackage {
+  @Nullable
+  @Override
+  public NativeModule getModule(@NonNull String name, @NonNull ReactApplicationContext reactContext) {
+    return null;
+  }
+
+  @NonNull
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return HashMap::new;
+  }
+
+  static {
+    ChilkatRNOnLoad.initializeNative();
+  }
+}

package/chilkat-checksums.json

@@ -0,0 +1,9 @@
+{
+  "_generated": "Generated by ReactNativeNs.RnGenerator -- do not edit. SHA-256 of every native archive published for this version; scripts/fetch-chilkat.js refuses an archive whose digest is not listed. ChilkatDist (PublishReactNative) rewrites the rows; an ordinary generator run keeps whatever is listed.",
+  "version": "11.6.1",
+  "baseUrl": "https://chilkatdownload.com/11.6.1/",
+  "archives": {
+    "chilkat-rn-android.tar.gz": "72d6b29f34ad4c86e0373fd95613050d05b1f6b8fb5c3deeabfc7d646bb497f1",
+    "chilkat-rn-ios.tar.gz": "83e765ddcf2f074f0fe36612de35d84c4ddb6693514fc58c4b451f76919f3052"
+  }
+}