@salve-software/mako-react-native 1.0.1

package/lib/typescript/src/library/performance-handler/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Performance handler types
+ */
+import type { NitroMako as NitroMakoSpec } from '../../specs/mako.nitro';
+export interface PerformanceHandlerConfig {
+    nitroMako: NitroMakoSpec;
+    onEvent: (event: PerformanceMetricsEvent) => void;
+    intervalMs?: number;
+}
+export interface PerformanceMetricsEvent {
+    type: 'performance_metrics';
+    timestamp: number;
+    deviceId?: string;
+    projectId?: string;
+    uiFps: number;
+    jsFps: number;
+    memoryUsage: number;
+    cpuUsage: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/library/performance-handler/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/library/performance-handler/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAExE,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,CAAA;IACjD,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,qBAAqB,CAAA;IAC3B,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;CACjB"}

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

@@ -0,0 +1,4 @@
+import { ProjectHandler } from './project-handler';
+export { ProjectHandler };
+export declare const projectHandler: ProjectHandler;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/library/project/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAElD,OAAO,EAAE,cAAc,EAAE,CAAA;AACzB,eAAO,MAAM,cAAc,gBAAuB,CAAA"}

package/lib/typescript/src/library/project/project-handler.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectInfoEvent } from '../types';
+export declare class ProjectHandler {
+    private cachedProjectId;
+    getProjectId(): string;
+    getProjectInfo(): Omit<ProjectInfoEvent, 'type'>;
+}
+//# sourceMappingURL=project-handler.d.ts.map

package/lib/typescript/src/library/project/project-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-handler.d.ts","sourceRoot":"","sources":["../../../../../src/library/project/project-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,qBAAa,cAAc;IACzB,OAAO,CAAC,eAAe,CAAsB;IAE7C,YAAY,IAAI,MAAM;IAUtB,cAAc,IAAI,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC;CAWjD"}

package/lib/typescript/src/library/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Mako SDK Types
+ */
+export type { LogLevel, LogSource, NativeLogSource, LogEvent, NativeLogEvent, NetworkStage, NetworkRequestEvent, NetworkResponseEvent, NetworkEvent, DeviceInfoEvent, ProjectInfoEvent, ComponentRenderEvent, ComponentTreeEvent, PerformanceMetricsEvent, EventType, MakoEvent, } from '@salve-software/mako-types';
+export interface MakoConfig {
+    /** Host IP/hostname of the Mako macOS app (default: 'localhost') */
+    host?: string;
+    /** WebSocket port (default: 8765) */
+    port?: number;
+    /** Enable network request/response capture (default: true) */
+    enableNetworkCapture?: boolean;
+    /** Enable component inspector for React render tracking (default: false) */
+    enableComponentInspector?: boolean;
+    /** Enable performance monitoring for FPS, memory, and CPU tracking (default: false) */
+    enablePerformanceMonitoring?: boolean;
+    /** URL patterns to ignore (default includes Metro bundler URLs) */
+    ignoredUrls?: RegExp[];
+    /** Callback when connected to Mako */
+    onConnect?: () => void;
+    /** Callback when disconnected from Mako */
+    onDisconnect?: () => void;
+    /** Callback on connection error */
+    onError?: (error: Error) => void;
+}
+export interface PendingRequest {
+    id: string;
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: string;
+    startTime: number;
+    responseHeaders?: Record<string, string>;
+}
+export interface NetworkCallbacks {
+    onOpen: (method: string, url: string, xhr: XMLHttpRequest) => void;
+    onSend: (data: unknown, xhr: XMLHttpRequest) => void;
+    onRequestHeader: (header: string, value: string, xhr: XMLHttpRequest) => void;
+    onHeaderReceived: (responseContentType: string | undefined, responseSize: number | undefined, responseHeaders: string, xhr: XMLHttpRequest) => void;
+    onResponse: (status: number, timeout: boolean, response: unknown, responseURL: string, responseType: string, xhr: XMLHttpRequest) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/library/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/library/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,YAAY,EACV,QAAQ,EACR,SAAS,EACT,eAAe,EACf,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,EACZ,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,EACvB,SAAS,EACT,SAAS,GACV,MAAM,4BAA4B,CAAC;AAMpC,MAAM,WAAW,UAAU;IACzB,oEAAoE;IACpE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,4EAA4E;IAC5E,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,uFAAuF;IACvF,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,sCAAsC;IACtC,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,mCAAmC;IACnC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAClC;AAMD,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,KAAK,IAAI,CAAC;IACnE,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,KAAK,IAAI,CAAC;IACrD,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9E,gBAAgB,EAAE,CAChB,mBAAmB,EAAE,MAAM,GAAG,SAAS,EACvC,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,eAAe,EAAE,MAAM,EACvB,GAAG,EAAE,cAAc,KAChB,IAAI,CAAC;IACV,UAAU,EAAE,CACV,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,OAAO,EACjB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,cAAc,KAChB,IAAI,CAAC;CACX"}

package/lib/typescript/src/specs/mako.nitro.d.ts

@@ -0,0 +1,100 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+/**
+ * Log level for native logs
+ * Note: Using 'verbose' instead of 'debug' to avoid conflict with iOS DEBUG preprocessor macro
+ */
+export type NativeLogLevel = 'verbose' | 'info' | 'warn' | 'error';
+/**
+ * Native log entry received from iOS/Android
+ */
+export interface NativeLogEntry {
+    level: NativeLogLevel;
+    message: string;
+    tag: string;
+    timestamp: number;
+}
+/**
+ * Callback type for receiving native logs
+ */
+export type NativeLogCallback = (log: NativeLogEntry) => void;
+/**
+ * Device information result from native APIs
+ */
+export interface DeviceInfoResult {
+    deviceId: string;
+    deviceName: string;
+    appName: string;
+    bundleId: string;
+}
+/**
+ * Performance metrics snapshot from native APIs
+ */
+export interface PerformanceMetrics {
+    uiFps: number;
+    jsFps: number;
+    memoryUsageMB: number;
+    cpuUsagePercent: number;
+}
+/**
+ * Callback type for receiving performance metrics
+ */
+export type PerformanceMetricsCallback = (metrics: PerformanceMetrics) => void;
+export interface NitroMako extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    sum(num1: number, num2: number): number;
+    /**
+     * Start capturing native platform logs (NSLog/print on iOS, Logcat on Android)
+     * @param onLog Callback invoked for each captured log entry
+     * @returns true if capture started successfully
+     */
+    startLogCapture(onLog: NativeLogCallback): boolean;
+    /**
+     * Stop capturing native platform logs
+     */
+    stopLogCapture(): void;
+    /**
+     * Check if log capture is currently active
+     */
+    isCapturing(): boolean;
+    /**
+     * Get device information using native APIs
+     * @returns Device info including deviceId, deviceName, appName, and bundleId
+     */
+    getDeviceInfo(): DeviceInfoResult;
+    /**
+     * Get stored device ID from native storage (UserDefaults/SharedPreferences)
+     * @returns The stored device ID or undefined if not found
+     */
+    getStoredDeviceId(): string | undefined;
+    /**
+     * Store device ID in native storage (UserDefaults/SharedPreferences)
+     * @param deviceId The device ID to store
+     */
+    storeDeviceId(deviceId: string): void;
+    /**
+     * Start monitoring performance metrics (FPS, memory, CPU)
+     * @param onMetrics Callback invoked with performance snapshot
+     * @param intervalMs How often to report metrics (in milliseconds, default 1000)
+     * @returns true if monitoring started successfully
+     */
+    startPerformanceMonitoring(onMetrics: PerformanceMetricsCallback, intervalMs?: number): boolean;
+    /**
+     * Stop monitoring performance metrics
+     */
+    stopPerformanceMonitoring(): void;
+    /**
+     * Check if performance monitoring is currently active
+     */
+    isPerformanceMonitoring(): boolean;
+    /**
+     * Get current performance metrics snapshot (without starting monitoring)
+     */
+    getPerformanceSnapshot(): PerformanceMetrics;
+    /**
+     * Record a JS frame tick (called from JS to track JS thread responsiveness)
+     */
+    recordJsFrame(): void;
+}
+//# sourceMappingURL=mako.nitro.d.ts.map

package/lib/typescript/src/specs/mako.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mako.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/mako.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;AAElE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,cAAc,CAAA;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,CAAA;AAE7D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,CAAA;CACxB;AAED;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,OAAO,EAAE,kBAAkB,KAAK,IAAI,CAAA;AAE9E,MAAM,WAAW,SAAU,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAClF,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IAEvC;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAA;IAElD;;OAEG;IACH,cAAc,IAAI,IAAI,CAAA;IAEtB;;OAEG;IACH,WAAW,IAAI,OAAO,CAAA;IAEtB;;;OAGG;IACH,aAAa,IAAI,gBAAgB,CAAA;IAEjC;;;OAGG;IACH,iBAAiB,IAAI,MAAM,GAAG,SAAS,CAAA;IAEvC;;;OAGG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAErC;;;;;OAKG;IACH,0BAA0B,CAAC,SAAS,EAAE,0BAA0B,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IAE/F;;OAEG;IACH,yBAAyB,IAAI,IAAI,CAAA;IAEjC;;OAEG;IACH,uBAAuB,IAAI,OAAO,CAAA;IAElC;;OAEG;IACH,sBAAsB,IAAI,kBAAkB,CAAA;IAE5C;;OAEG;IACH,aAAa,IAAI,IAAI,CAAA;CACtB"}

package/nitro.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": ["mako"],
+  "ios": {
+    "iosModuleName": "NitroMako"
+  },
+  "android": {
+    "androidNamespace": ["mako"],
+    "androidCxxLibName": "NitroMako"
+  },
+  "autolinking": {
+    "NitroMako": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridMako"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridMako"
+      }
+    }
+  },
+  "ignorePaths": ["**/node_modules"]
+}

package/nitrogen/generated/.gitattributes

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

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

@@ -0,0 +1,81 @@
+#
+# NitroMako+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/NitroMako+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_NITROMAKO_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)
+  NitroMako PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/NitroMakoOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridNitroMakoSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridNitroMakoSpec.cpp
+)
+
+# 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(
+  NitroMako 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(
+        NitroMako
+        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(
+        NitroMako
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        NitroMako
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/NitroMako+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// NitroMako+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/NitroMako+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 NitroMako is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/NitroMakoOnLoad.cpp

@@ -0,0 +1,58 @@
+///
+/// NitroMakoOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_NITROMAKO_WITH_GENERATED_CMAKE_PROJECT
+#error NitroMakoOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "NitroMakoOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridNitroMakoSpec.hpp"
+#include "JFunc_void_NativeLogEntry.hpp"
+#include "JFunc_void_PerformanceMetrics.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::mako {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::mako::registerAllNatives();
+  });
+}
+
+struct JHybridNitroMakoSpecImpl: public jni::JavaClass<JHybridNitroMakoSpecImpl, JHybridNitroMakoSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/mako/HybridMako;";
+  static std::shared_ptr<JHybridNitroMakoSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridNitroMakoSpecImpl::javaobject()>();
+    jni::local_ref<JHybridNitroMakoSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridNitroMakoSpec();
+  }
+};
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::mako;
+
+  // Register native JNI methods
+  margelo::nitro::mako::JHybridNitroMakoSpec::CxxPart::registerNatives();
+  margelo::nitro::mako::JFunc_void_NativeLogEntry_cxx::registerNatives();
+  margelo::nitro::mako::JFunc_void_PerformanceMetrics_cxx::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NitroMako",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridNitroMakoSpecImpl::create();
+    }
+  );
+}
+
+} // namespace margelo::nitro::mako

package/nitrogen/generated/android/NitroMakoOnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// NitroMakoOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::mako {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of NitroMako, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all NitroMako HybridObjects
+   *     margelo::nitro::mako::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::mako

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

@@ -0,0 +1,69 @@
+///
+/// JDeviceInfoResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "DeviceInfoResult.hpp"
+
+#include <string>
+
+namespace margelo::nitro::mako {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DeviceInfoResult" and the the Kotlin data class "DeviceInfoResult".
+   */
+  struct JDeviceInfoResult final: public jni::JavaClass<JDeviceInfoResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/mako/DeviceInfoResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DeviceInfoResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DeviceInfoResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDeviceId = clazz->getField<jni::JString>("deviceId");
+      jni::local_ref<jni::JString> deviceId = this->getFieldValue(fieldDeviceId);
+      static const auto fieldDeviceName = clazz->getField<jni::JString>("deviceName");
+      jni::local_ref<jni::JString> deviceName = this->getFieldValue(fieldDeviceName);
+      static const auto fieldAppName = clazz->getField<jni::JString>("appName");
+      jni::local_ref<jni::JString> appName = this->getFieldValue(fieldAppName);
+      static const auto fieldBundleId = clazz->getField<jni::JString>("bundleId");
+      jni::local_ref<jni::JString> bundleId = this->getFieldValue(fieldBundleId);
+      return DeviceInfoResult(
+        deviceId->toStdString(),
+        deviceName->toStdString(),
+        appName->toStdString(),
+        bundleId->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDeviceInfoResult::javaobject> fromCpp(const DeviceInfoResult& value) {
+      using JSignature = JDeviceInfoResult(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.deviceId),
+        jni::make_jstring(value.deviceName),
+        jni::make_jstring(value.appName),
+        jni::make_jstring(value.bundleId)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::mako

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

@@ -0,0 +1,80 @@
+///
+/// JFunc_void_NativeLogEntry.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "NativeLogEntry.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JNativeLogEntry.hpp"
+#include "NativeLogLevel.hpp"
+#include "JNativeLogLevel.hpp"
+#include <string>
+
+namespace margelo::nitro::mako {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(log: NativeLogEntry) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_NativeLogEntry: public jni::JavaClass<JFunc_void_NativeLogEntry> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/mako/Func_void_NativeLogEntry;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_NativeLogEntry` instance holds through JNI.
+     */
+    void invoke(const NativeLogEntry& log) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JNativeLogEntry> /* log */)>("invoke");
+      method(self(), JNativeLogEntry::fromCpp(log));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_NativeLogEntry that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_NativeLogEntry_cxx final: public jni::HybridClass<JFunc_void_NativeLogEntry_cxx, JFunc_void_NativeLogEntry> {
+  public:
+    static jni::local_ref<JFunc_void_NativeLogEntry::javaobject> fromCpp(const std::function<void(const NativeLogEntry& /* log */)>& func) {
+      return JFunc_void_NativeLogEntry_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_NativeLogEntry_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JNativeLogEntry> log) {
+      _func(log->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const NativeLogEntry& /* log */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/mako/Func_void_NativeLogEntry_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_NativeLogEntry_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_NativeLogEntry_cxx(const std::function<void(const NativeLogEntry& /* log */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const NativeLogEntry& /* log */)> _func;
+  };
+
+} // namespace margelo::nitro::mako

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_PerformanceMetrics.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "PerformanceMetrics.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JPerformanceMetrics.hpp"
+
+namespace margelo::nitro::mako {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(metrics: PerformanceMetrics) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_PerformanceMetrics: public jni::JavaClass<JFunc_void_PerformanceMetrics> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/mako/Func_void_PerformanceMetrics;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_PerformanceMetrics` instance holds through JNI.
+     */
+    void invoke(const PerformanceMetrics& metrics) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPerformanceMetrics> /* metrics */)>("invoke");
+      method(self(), JPerformanceMetrics::fromCpp(metrics));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_PerformanceMetrics that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_PerformanceMetrics_cxx final: public jni::HybridClass<JFunc_void_PerformanceMetrics_cxx, JFunc_void_PerformanceMetrics> {
+  public:
+    static jni::local_ref<JFunc_void_PerformanceMetrics::javaobject> fromCpp(const std::function<void(const PerformanceMetrics& /* metrics */)>& func) {
+      return JFunc_void_PerformanceMetrics_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_PerformanceMetrics_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JPerformanceMetrics> metrics) {
+      _func(metrics->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const PerformanceMetrics& /* metrics */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/mako/Func_void_PerformanceMetrics_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_PerformanceMetrics_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_PerformanceMetrics_cxx(const std::function<void(const PerformanceMetrics& /* metrics */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const PerformanceMetrics& /* metrics */)> _func;
+  };
+
+} // namespace margelo::nitro::mako