react-native-nitro-logger 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileSink.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/FileSink.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,sDAAsD;IACtD,gBAAgB,EAAE,MAAM,CAAC;IACzB,iDAAiD;IACjD,qBAAqB,EAAE,MAAM,CAAC;IAC9B,iEAAiE;IACjE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,wCAAwC;IACxC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,mEAAmE;IACnE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,qDAAqD;IACrD,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,2CAA2C;AAC3C,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE5E;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,gFAAgF;IAChF,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,0EAA0E;IAC1E,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,gEAAgE;IAChE,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;;;;;;;;;OAaG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAS,SAAQ,YAAY,CAAC;IAC7C,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,QAAQ,CAAC;CACnB,CAAC;IACA,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IAErC;;;;;;;;;;OAUG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAE1E;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,YAAY,CAAC;IAE7D,4EAA4E;IAC5E,SAAS,IAAI,UAAU,CAAC;IAExB,oDAAoD;IACpD,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAAC;IAExC,kEAAkE;IAClE,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAAC;IAExC,4CAA4C;IAC5C,eAAe,IAAI,MAAM,EAAE,CAAC;IAE5B;;;;;OAKG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAAC;CAC7C"}

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

@@ -0,0 +1,21 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+/**
+ * Routes pre-formatted lines to the platform's native log stream so JS logs
+ * interleave with native ones — os_log on iOS (Console.app / Xcode), logcat
+ * on Android.
+ *
+ * Levels cross as numeric codes 0–5 (verbose…todo) and map natively:
+ * verbose/debug → .debug, info → .info, warning → .default, error → .error,
+ * todo → .fault (iOS); Log.println priorities on Android.
+ *
+ * Batched like the file sink: one logBatch call per Batcher drain, parallel
+ * primitive arrays, no per-entry struct marshaling.
+ */
+export interface NativeConsoleSink extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    install(subsystem: string, category: string): void;
+    logBatch(levels: number[], messages: string[]): void;
+}
+//# sourceMappingURL=NativeConsoleSink.nitro.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NativeConsoleSink.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/NativeConsoleSink.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAkB,SAAQ,YAAY,CAAC;IACtD,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,QAAQ,CAAC;CACnB,CAAC;IACA,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CACtD"}

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

@@ -0,0 +1,37 @@
+import type { PrivateValue, PublicValue } from './privacy.js';
+export type { PrivateValue, PublicValue };
+/** Severity levels, least to most severe. `todo` marks incomplete work and
+ * sorts highest so it always surfaces (SwiftLogger parity). */
+export type LogLevel = 'verbose' | 'debug' | 'info' | 'warning' | 'error' | 'todo';
+/** Messages accept a thunk so hot-path callers can defer interpolation —
+ * the `@autoclosure` equivalent. The thunk is NOT invoked when the entry is
+ * filtered out or no destination is eligible. */
+export type LazyMessage = string | (() => string);
+/** The only value shapes the pipeline can render. */
+export type LogPrimitive = string | number | boolean;
+/** Metadata values: a bare primitive, whose visibility follows the privacy
+ * default, or one explicitly marked with `pub()` / `priv()`. */
+export type LogValue = LogPrimitive | PublicValue | PrivateValue;
+export type LogMetadata = Record<string, LogValue>;
+/** Metadata after redaction — what formatters and destinations see. Privacy
+ * markers are unrepresentable here by construction: every value has already
+ * been resolved to a primitive or replaced by a placeholder. */
+export type RedactedMetadata = Readonly<Record<string, LogPrimitive>>;
+/** A single log event, post-redaction. Readonly and frozen at runtime: one
+ * entry fans out to every destination, so no destination may mutate what its
+ * siblings receive. No file/function/line: JS has no `#fileID`, and Hermes
+ * stack parsing is unreliable — subsystems are the filtering mechanism
+ * instead. */
+export interface LogEntry {
+    /** Epoch milliseconds, not a `Date`: `Object.freeze` does not protect a
+     * Date's internal slots, so a destination could `setTime()` the entry its
+     * siblings are about to receive. A number is immutable by construction and
+     * crosses the native bridge unchanged. */
+    readonly timestamp: number;
+    readonly level: LogLevel;
+    readonly message: string;
+    readonly metadata?: RedactedMetadata;
+    readonly correlation?: string;
+    readonly subsystem?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,cAAW,CAAC;AAE3D,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,CAAC;AAE1C;+DAC+D;AAC/D,MAAM,MAAM,QAAQ,GAClB,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;AAE9D;;iDAEiD;AACjD,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAC;AAElD,qDAAqD;AACrD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAErD;gEACgE;AAChE,MAAM,MAAM,QAAQ,GAAG,YAAY,GAAG,WAAW,GAAG,YAAY,CAAC;AAEjE,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AAEnD;;gEAEgE;AAChE,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;AAEtE;;;;cAIc;AACd,MAAM,WAAW,QAAQ;IACvB;;;8CAG0C;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B"}

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

@@ -0,0 +1,15 @@
+/**
+ * UTF-8 byte length, without allocating an encoder.
+ *
+ * `TextEncoder` is not guaranteed on every Hermes build this package targets,
+ * and counting is cheaper than encoding when the answer is all that is
+ * wanted. Every byte budget in this package — the sink's payload cap, the
+ * batcher's pending cap, a formatter's truncation limit — is a UTF-8 budget,
+ * because that is what actually reaches the file.
+ *
+ * An unpaired surrogate counts as 3, matching every standard encoder: it has
+ * no UTF-8 form of its own, so encoders substitute U+FFFD, which is three
+ * bytes.
+ */
+export declare function utf8Length(text: string): number;
+//# sourceMappingURL=utf8.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utf8.d.ts","sourceRoot":"","sources":["../../../src/utf8.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAyB/C"}

package/nitro.json

@@ -0,0 +1,33 @@
+{
+  "cxxNamespace": ["nitrologger"],
+  "ios": {
+    "iosModuleName": "NitroLogger"
+  },
+  "android": {
+    "androidNamespace": ["nitrologger"],
+    "androidCxxLibName": "nitrologger"
+  },
+  "autolinking": {
+    "FileSink": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridFileSink"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridFileSink"
+      }
+    },
+    "NativeConsoleSink": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridNativeConsoleSink"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridNativeConsoleSink"
+      }
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

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

@@ -0,0 +1,79 @@
+///
+/// JAppendResult.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 "AppendResult.hpp"
+
+#include "JRejectReason.hpp"
+#include "RejectReason.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrologger {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AppendResult" and the Kotlin data class "AppendResult".
+   */
+  struct JAppendResult final: public jni::JavaClass<JAppendResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrologger/AppendResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AppendResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AppendResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAccepted = clazz->getField<jboolean>("accepted");
+      jboolean accepted = this->getFieldValue(fieldAccepted);
+      static const auto fieldRejectReason = clazz->getField<JRejectReason>("rejectReason");
+      jni::local_ref<JRejectReason> rejectReason = this->getFieldValue(fieldRejectReason);
+      static const auto fieldQueuedBytes = clazz->getField<double>("queuedBytes");
+      double queuedBytes = this->getFieldValue(fieldQueuedBytes);
+      static const auto fieldLostBytes = clazz->getField<double>("lostBytes");
+      double lostBytes = this->getFieldValue(fieldLostBytes);
+      static const auto fieldLostEntries = clazz->getField<double>("lostEntries");
+      double lostEntries = this->getFieldValue(fieldLostEntries);
+      static const auto fieldDegraded = clazz->getField<double>("degraded");
+      double degraded = this->getFieldValue(fieldDegraded);
+      return AppendResult(
+        static_cast<bool>(accepted),
+        rejectReason != nullptr ? std::make_optional(rejectReason->toCpp()) : std::nullopt,
+        queuedBytes,
+        lostBytes,
+        lostEntries,
+        degraded
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JAppendResult::javaobject> fromCpp(const AppendResult& value) {
+      using JSignature = JAppendResult(jboolean, jni::alias_ref<JRejectReason>, double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.accepted,
+        value.rejectReason.has_value() ? JRejectReason::fromCpp(value.rejectReason.value()) : nullptr,
+        value.queuedBytes,
+        value.lostBytes,
+        value.lostEntries,
+        value.degraded
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrologger

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

@@ -0,0 +1,88 @@
+///
+/// JClearOutcome.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 "ClearOutcome.hpp"
+
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::nitrologger {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ClearOutcome" and the Kotlin data class "ClearOutcome".
+   */
+  struct JClearOutcome final: public jni::JavaClass<JClearOutcome> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrologger/ClearOutcome;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ClearOutcome by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ClearOutcome toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDeletedCount = clazz->getField<double>("deletedCount");
+      double deletedCount = this->getFieldValue(fieldDeletedCount);
+      static const auto fieldFailedPaths = clazz->getField<jni::JArrayClass<jni::JString>>("failedPaths");
+      jni::local_ref<jni::JArrayClass<jni::JString>> failedPaths = this->getFieldValue(fieldFailedPaths);
+      static const auto fieldDurable = clazz->getField<jboolean>("durable");
+      jboolean durable = this->getFieldValue(fieldDurable);
+      static const auto fieldRebound = clazz->getField<jboolean>("rebound");
+      jboolean rebound = this->getFieldValue(fieldRebound);
+      return ClearOutcome(
+        deletedCount,
+        [&](auto&& __input) {
+          size_t __size = __input->size();
+          std::vector<std::string> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __input->getElement(__i);
+            __vector.push_back(__element->toStdString());
+          }
+          return __vector;
+        }(failedPaths),
+        static_cast<bool>(durable),
+        static_cast<bool>(rebound)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JClearOutcome::javaobject> fromCpp(const ClearOutcome& value) {
+      using JSignature = JClearOutcome(double, jni::alias_ref<jni::JArrayClass<jni::JString>>, jboolean, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.deletedCount,
+        [&](auto&& __input) {
+          size_t __size = __input.size();
+          jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = __input[__i];
+            auto __elementJni = jni::make_jstring(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(value.failedPaths),
+        value.durable,
+        value.rebound
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrologger

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

@@ -0,0 +1,81 @@
+///
+/// JFlushOutcome.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 "FlushOutcome.hpp"
+
+
+
+namespace margelo::nitro::nitrologger {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "FlushOutcome" and the Kotlin data class "FlushOutcome".
+   */
+  struct JFlushOutcome final: public jni::JavaClass<JFlushOutcome> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrologger/FlushOutcome;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct FlushOutcome by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    FlushOutcome toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDurable = clazz->getField<jboolean>("durable");
+      jboolean durable = this->getFieldValue(fieldDurable);
+      static const auto fieldTimedOut = clazz->getField<jboolean>("timedOut");
+      jboolean timedOut = this->getFieldValue(fieldTimedOut);
+      static const auto fieldPendingBytes = clazz->getField<double>("pendingBytes");
+      double pendingBytes = this->getFieldValue(fieldPendingBytes);
+      static const auto fieldQueuedBytes = clazz->getField<double>("queuedBytes");
+      double queuedBytes = this->getFieldValue(fieldQueuedBytes);
+      static const auto fieldLostBytes = clazz->getField<double>("lostBytes");
+      double lostBytes = this->getFieldValue(fieldLostBytes);
+      static const auto fieldLostEntries = clazz->getField<double>("lostEntries");
+      double lostEntries = this->getFieldValue(fieldLostEntries);
+      static const auto fieldDegraded = clazz->getField<double>("degraded");
+      double degraded = this->getFieldValue(fieldDegraded);
+      return FlushOutcome(
+        static_cast<bool>(durable),
+        static_cast<bool>(timedOut),
+        pendingBytes,
+        queuedBytes,
+        lostBytes,
+        lostEntries,
+        degraded
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JFlushOutcome::javaobject> fromCpp(const FlushOutcome& value) {
+      using JSignature = JFlushOutcome(jboolean, jboolean, double, double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.durable,
+        value.timedOut,
+        value.pendingBytes,
+        value.queuedBytes,
+        value.lostBytes,
+        value.lostEntries,
+        value.degraded
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrologger

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

@@ -0,0 +1,120 @@
+///
+/// JHybridFileSinkSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridFileSinkSpec.hpp"
+
+// Forward declaration of `AppendResult` to properly resolve imports.
+namespace margelo::nitro::nitrologger { struct AppendResult; }
+// Forward declaration of `RejectReason` to properly resolve imports.
+namespace margelo::nitro::nitrologger { enum class RejectReason; }
+// Forward declaration of `SinkStatus` to properly resolve imports.
+namespace margelo::nitro::nitrologger { struct SinkStatus; }
+// Forward declaration of `FlushOutcome` to properly resolve imports.
+namespace margelo::nitro::nitrologger { struct FlushOutcome; }
+// Forward declaration of `ClearOutcome` to properly resolve imports.
+namespace margelo::nitro::nitrologger { struct ClearOutcome; }
+// Forward declaration of `RotationConfig` to properly resolve imports.
+namespace margelo::nitro::nitrologger { struct RotationConfig; }
+
+#include <string>
+#include "AppendResult.hpp"
+#include "JAppendResult.hpp"
+#include "RejectReason.hpp"
+#include <optional>
+#include "JRejectReason.hpp"
+#include "SinkStatus.hpp"
+#include "JSinkStatus.hpp"
+#include "FlushOutcome.hpp"
+#include "JFlushOutcome.hpp"
+#include <vector>
+#include "ClearOutcome.hpp"
+#include "JClearOutcome.hpp"
+#include "RotationConfig.hpp"
+#include "JRotationConfig.hpp"
+
+namespace margelo::nitro::nitrologger {
+
+  std::shared_ptr<JHybridFileSinkSpec> JHybridFileSinkSpec::JavaPart::getJHybridFileSinkSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridFileSinkSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridFileSinkSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridFileSinkSpec::CxxPart::jhybriddata> JHybridFileSinkSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridFileSinkSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridFileSinkSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridFileSinkSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridFileSinkSpec>(castJavaPart);
+  }
+
+  void JHybridFileSinkSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridFileSinkSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  std::string JHybridFileSinkSpec::getDefaultLogDirectory() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getDefaultLogDirectory");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+
+  // Methods
+  void JHybridFileSinkSpec::open(const std::string& path, const std::optional<RotationConfig>& rotation, std::optional<bool> lineFramed) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* path */, jni::alias_ref<JRotationConfig> /* rotation */, jni::alias_ref<jni::JBoolean> /* lineFramed */)>("open");
+    method(_javaPart, jni::make_jstring(path), rotation.has_value() ? JRotationConfig::fromCpp(rotation.value()) : nullptr, lineFramed.has_value() ? jni::JBoolean::valueOf(lineFramed.value()) : nullptr);
+  }
+  AppendResult JHybridFileSinkSpec::appendBatch(const std::string& batch, double entryCount) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JAppendResult>(jni::alias_ref<jni::JString> /* batch */, double /* entryCount */)>("appendBatch");
+    auto __result = method(_javaPart, jni::make_jstring(batch), entryCount);
+    return __result->toCpp();
+  }
+  SinkStatus JHybridFileSinkSpec::getStatus() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JSinkStatus>()>("getStatus");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  FlushOutcome JHybridFileSinkSpec::flush(double deadlineMs) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFlushOutcome>(double /* deadlineMs */)>("flush");
+    auto __result = method(_javaPart, deadlineMs);
+    return __result->toCpp();
+  }
+  FlushOutcome JHybridFileSinkSpec::close(double deadlineMs) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFlushOutcome>(double /* deadlineMs */)>("close");
+    auto __result = method(_javaPart, deadlineMs);
+    return __result->toCpp();
+  }
+  std::vector<std::string> JHybridFileSinkSpec::getLogFilePaths() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>()>("getLogFilePaths");
+    auto __result = method(_javaPart);
+    return [&](auto&& __input) {
+      size_t __size = __input->size();
+      std::vector<std::string> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __input->getElement(__i);
+        __vector.push_back(__element->toStdString());
+      }
+      return __vector;
+    }(__result);
+  }
+  ClearOutcome JHybridFileSinkSpec::clearLogs(double deadlineMs) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JClearOutcome>(double /* deadlineMs */)>("clearLogs");
+    auto __result = method(_javaPart, deadlineMs);
+    return __result->toCpp();
+  }
+
+} // namespace margelo::nitro::nitrologger

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

@@ -0,0 +1,69 @@
+///
+/// HybridFileSinkSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridFileSinkSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrologger {
+
+  using namespace facebook;
+
+  class JHybridFileSinkSpec: public virtual HybridFileSinkSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrologger/HybridFileSinkSpec;";
+      std::shared_ptr<JHybridFileSinkSpec> getJHybridFileSinkSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrologger/HybridFileSinkSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridFileSinkSpec(const jni::local_ref<JHybridFileSinkSpec::JavaPart>& javaPart):
+      HybridObject(HybridFileSinkSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridFileSinkSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridFileSinkSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::string getDefaultLogDirectory() override;
+
+  public:
+    // Methods
+    void open(const std::string& path, const std::optional<RotationConfig>& rotation, std::optional<bool> lineFramed) override;
+    AppendResult appendBatch(const std::string& batch, double entryCount) override;
+    SinkStatus getStatus() override;
+    FlushOutcome flush(double deadlineMs) override;
+    FlushOutcome close(double deadlineMs) override;
+    std::vector<std::string> getLogFilePaths() override;
+    ClearOutcome clearLogs(double deadlineMs) override;
+
+  private:
+    jni::global_ref<JHybridFileSinkSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrologger

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

@@ -0,0 +1,71 @@
+///
+/// JHybridNativeConsoleSinkSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridNativeConsoleSinkSpec.hpp"
+
+
+
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::nitrologger {
+
+  std::shared_ptr<JHybridNativeConsoleSinkSpec> JHybridNativeConsoleSinkSpec::JavaPart::getJHybridNativeConsoleSinkSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridNativeConsoleSinkSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridNativeConsoleSinkSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridNativeConsoleSinkSpec::CxxPart::jhybriddata> JHybridNativeConsoleSinkSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridNativeConsoleSinkSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridNativeConsoleSinkSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridNativeConsoleSinkSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridNativeConsoleSinkSpec>(castJavaPart);
+  }
+
+  void JHybridNativeConsoleSinkSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNativeConsoleSinkSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridNativeConsoleSinkSpec::install(const std::string& subsystem, const std::string& category) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* subsystem */, jni::alias_ref<jni::JString> /* category */)>("install");
+    method(_javaPart, jni::make_jstring(subsystem), jni::make_jstring(category));
+  }
+  void JHybridNativeConsoleSinkSpec::logBatch(const std::vector<double>& levels, const std::vector<std::string>& messages) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayDouble> /* levels */, jni::alias_ref<jni::JArrayClass<jni::JString>> /* messages */)>("logBatch");
+    method(_javaPart, [&]() {
+      size_t __size = levels.size();
+      jni::local_ref<jni::JArrayDouble> __array = jni::JArrayDouble::newArray(__size);
+      __array->setRegion(0, __size, levels.data());
+      return __array;
+    }(), [&](auto&& __input) {
+      size_t __size = __input.size();
+      jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = __input[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(messages));
+  }
+
+} // namespace margelo::nitro::nitrologger