@kookyleo/graphviz-anywhere-rn 0.1.0

package/android/build.gradle

@@ -0,0 +1,72 @@
+buildscript {
+    def kotlinVersion = rootProject.ext.has("kotlinVersion")
+            ? rootProject.ext.get("kotlinVersion")
+            : "1.9.25"
+
+    repositories {
+        google()
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+    }
+}
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+apply plugin: "com.android.library"
+
+android {
+    namespace "com.graphviznative"
+    compileSdkVersion safeExtGet("compileSdkVersion", 35)
+
+    defaultConfig {
+        minSdkVersion safeExtGet("minSdkVersion", 24)
+        targetSdkVersion safeExtGet("targetSdkVersion", 35)
+
+        externalNativeBuild {
+            cmake {
+                cppFlags ""
+                arguments "-DANDROID_STL=c++_shared"
+            }
+        }
+
+        ndk {
+            abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path "src/main/CMakeLists.txt"
+            version "3.22.1"
+        }
+    }
+
+    buildFeatures {
+        prefab true
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs = ["src/main/java"]
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_11
+        targetCompatibility JavaVersion.VERSION_11
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation "com.facebook.react:react-android:+"
+}

package/android/src/main/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.22.1)
+project(graphviz_jni)
+
+# Build the graphviz_api C library from source
+set(GRAPHVIZ_API_SRC "${CMAKE_CURRENT_SOURCE_DIR}/../../../../src")
+
+add_library(graphviz_api SHARED
+    "${GRAPHVIZ_API_SRC}/graphviz_api.c"
+    jni/graphviz_jni.c
+)
+
+target_include_directories(graphviz_api PRIVATE
+    "${GRAPHVIZ_API_SRC}"
+)
+
+# Link against the prebuilt Graphviz libraries for Android
+set(GRAPHVIZ_PREBUILT "${CMAKE_CURRENT_SOURCE_DIR}/../../../../graphviz")
+
+target_include_directories(graphviz_api PRIVATE
+    "${GRAPHVIZ_PREBUILT}/include"
+)
+
+# Link Android log library for JNI
+find_library(log-lib log)
+target_link_libraries(graphviz_api ${log-lib})

package/android/src/main/java/com/graphviznative/GraphvizModule.java

@@ -0,0 +1,149 @@
+/*
+ * GraphvizModule.java
+ *
+ * React Native native module for Android.
+ * Manages a singleton Graphviz context and dispatches rendering
+ * to a background thread to keep the JS thread responsive.
+ *
+ * Licensed under the Apache License, Version 2.0
+ */
+
+package com.graphviznative;
+
+import android.util.Base64;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class GraphvizModule extends ReactContextBaseJavaModule {
+
+    private static final String TAG = "GraphvizNative";
+    private static final String MODULE_NAME = "GraphvizNative";
+
+    private static final Set<String> TEXT_FORMATS = new HashSet<>(
+        Arrays.asList("svg", "json", "dot", "xdot", "plain")
+    );
+
+    private final ExecutorService executor = Executors.newSingleThreadExecutor();
+    private long contextPtr = 0;
+
+    static {
+        System.loadLibrary("graphviz_api");
+    }
+
+    public GraphvizModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    @NonNull
+    public String getName() {
+        return MODULE_NAME;
+    }
+
+    @Override
+    public void invalidate() {
+        if (contextPtr != 0) {
+            nativeContextFree(contextPtr);
+            contextPtr = 0;
+        }
+        executor.shutdown();
+        super.invalidate();
+    }
+
+    /**
+     * Lazily create the native context. Must be called from the executor thread.
+     */
+    private synchronized long ensureContext() {
+        if (contextPtr == 0) {
+            contextPtr = nativeContextNew();
+            if (contextPtr == 0) {
+                Log.e(TAG, "Failed to create Graphviz context");
+            }
+        }
+        return contextPtr;
+    }
+
+    @ReactMethod
+    public void renderDot(String dot, String engine, String format, Promise promise) {
+        executor.execute(() -> {
+            try {
+                long ctx = ensureContext();
+                if (ctx == 0) {
+                    promise.reject("NOT_INITIALIZED", "Failed to initialize Graphviz context");
+                    return;
+                }
+
+                String[] result = new String[1];
+                int err = nativeRender(ctx, dot, engine, format, result);
+
+                if (err != 0) {
+                    String code = errorCodeToString(err);
+                    String message = nativeStrerror(err);
+                    promise.reject(code, message);
+                    return;
+                }
+
+                if (result[0] == null) {
+                    promise.reject("RENDER_FAILED", "Render returned null output");
+                    return;
+                }
+
+                // For text formats, return as-is; for binary formats, already base64 from JNI
+                promise.resolve(result[0]);
+
+            } catch (Exception e) {
+                Log.e(TAG, "Render failed with exception", e);
+                promise.reject("UNKNOWN", "Unexpected error: " + e.getMessage());
+            }
+        });
+    }
+
+    @ReactMethod
+    public void getVersion(Promise promise) {
+        try {
+            String version = nativeVersion();
+            promise.resolve(version);
+        } catch (Exception e) {
+            promise.reject("UNKNOWN", "Failed to get version: " + e.getMessage());
+        }
+    }
+
+    private static String errorCodeToString(int err) {
+        switch (err) {
+            case -1: return "NULL_INPUT";
+            case -2: return "INVALID_DOT";
+            case -3: return "LAYOUT_FAILED";
+            case -4: return "RENDER_FAILED";
+            case -5: return "INVALID_ENGINE";
+            case -6: return "INVALID_FORMAT";
+            case -7: return "OUT_OF_MEMORY";
+            case -8: return "NOT_INITIALIZED";
+            default: return "UNKNOWN";
+        }
+    }
+
+    /*
+     * JNI native methods.
+     * These are implemented in the CMake-built native library that
+     * wraps graphviz_api.h via JNI.
+     */
+    private static native long nativeContextNew();
+    private static native void nativeContextFree(long ctx);
+    private static native int nativeRender(long ctx, String dot, String engine,
+                                            String format, String[] outResult);
+    private static native String nativeStrerror(int err);
+    private static native String nativeVersion();
+}

package/android/src/main/java/com/graphviznative/GraphvizPackage.java

@@ -0,0 +1,37 @@
+/*
+ * GraphvizPackage.java
+ *
+ * React Native package registration for the Graphviz native module.
+ *
+ * Licensed under the Apache License, Version 2.0
+ */
+
+package com.graphviznative;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class GraphvizPackage implements ReactPackage {
+
+    @Override
+    @NonNull
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new GraphvizModule(reactContext));
+        return modules;
+    }
+
+    @Override
+    @NonNull
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/android/src/main/jni/graphviz_jni.c

@@ -0,0 +1,151 @@
+/*
+ * graphviz_jni.c
+ *
+ * JNI bridge between the Java GraphvizModule and the C graphviz_api.
+ * Handles string conversions and memory management across the JNI boundary.
+ *
+ * Licensed under the Apache License, Version 2.0
+ */
+
+#include <jni.h>
+#include <string.h>
+#include <stdlib.h>
+#include <android/log.h>
+
+#include "graphviz_api.h"
+
+#define TAG "GraphvizJNI"
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
+
+/* Base64 encoding table */
+static const char b64_table[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/**
+ * Simple base64 encoder for binary output (png, pdf, ps).
+ * Caller must free the returned string.
+ */
+static char *base64_encode(const char *data, size_t len, size_t *out_len) {
+    size_t olen = 4 * ((len + 2) / 3);
+    char *out = (char *)malloc(olen + 1);
+    if (!out) return NULL;
+
+    size_t i, j;
+    for (i = 0, j = 0; i < len;) {
+        uint32_t a = i < len ? (unsigned char)data[i++] : 0;
+        uint32_t b = i < len ? (unsigned char)data[i++] : 0;
+        uint32_t c = i < len ? (unsigned char)data[i++] : 0;
+        uint32_t triple = (a << 16) | (b << 8) | c;
+
+        out[j++] = b64_table[(triple >> 18) & 0x3F];
+        out[j++] = b64_table[(triple >> 12) & 0x3F];
+        out[j++] = b64_table[(triple >> 6) & 0x3F];
+        out[j++] = b64_table[triple & 0x3F];
+    }
+
+    /* Padding */
+    size_t mod = len % 3;
+    if (mod == 1) {
+        out[olen - 1] = '=';
+        out[olen - 2] = '=';
+    } else if (mod == 2) {
+        out[olen - 1] = '=';
+    }
+
+    out[olen] = '\0';
+    if (out_len) *out_len = olen;
+    return out;
+}
+
+/**
+ * Returns non-zero if the format produces text (not binary) output.
+ */
+static int is_text_format(const char *format) {
+    return (strcmp(format, "svg") == 0 ||
+            strcmp(format, "json") == 0 ||
+            strcmp(format, "dot") == 0 ||
+            strcmp(format, "xdot") == 0 ||
+            strcmp(format, "plain") == 0);
+}
+
+JNIEXPORT jlong JNICALL
+Java_com_graphviznative_GraphvizModule_nativeContextNew(JNIEnv *env, jclass clazz) {
+    gv_context_t *ctx = gv_context_new();
+    return (jlong)(intptr_t)ctx;
+}
+
+JNIEXPORT void JNICALL
+Java_com_graphviznative_GraphvizModule_nativeContextFree(JNIEnv *env, jclass clazz, jlong ptr) {
+    gv_context_t *ctx = (gv_context_t *)(intptr_t)ptr;
+    if (ctx) {
+        gv_context_free(ctx);
+    }
+}
+
+JNIEXPORT jint JNICALL
+Java_com_graphviznative_GraphvizModule_nativeRender(
+    JNIEnv *env, jclass clazz,
+    jlong ptr, jstring jDot, jstring jEngine, jstring jFormat,
+    jobjectArray outResult
+) {
+    gv_context_t *ctx = (gv_context_t *)(intptr_t)ptr;
+
+    const char *dot = (*env)->GetStringUTFChars(env, jDot, NULL);
+    const char *engine = (*env)->GetStringUTFChars(env, jEngine, NULL);
+    const char *format = (*env)->GetStringUTFChars(env, jFormat, NULL);
+
+    if (!dot || !engine || !format) {
+        if (dot) (*env)->ReleaseStringUTFChars(env, jDot, dot);
+        if (engine) (*env)->ReleaseStringUTFChars(env, jEngine, engine);
+        if (format) (*env)->ReleaseStringUTFChars(env, jFormat, format);
+        return (jint)GV_ERR_NULL_INPUT;
+    }
+
+    char *outData = NULL;
+    size_t outLength = 0;
+
+    gv_error_t err = gv_render(ctx, dot, engine, format, &outData, &outLength);
+
+    if (err == GV_OK && outData) {
+        jstring result;
+        if (is_text_format(format)) {
+            result = (*env)->NewStringUTF(env, outData);
+        } else {
+            size_t b64Len = 0;
+            char *b64 = base64_encode(outData, outLength, &b64Len);
+            if (b64) {
+                result = (*env)->NewStringUTF(env, b64);
+                free(b64);
+            } else {
+                result = NULL;
+                err = GV_ERR_OUT_OF_MEMORY;
+            }
+        }
+
+        if (result) {
+            (*env)->SetObjectArrayElement(env, outResult, 0, result);
+        }
+    }
+
+    if (outData) {
+        gv_free_render_data(outData);
+    }
+
+    (*env)->ReleaseStringUTFChars(env, jDot, dot);
+    (*env)->ReleaseStringUTFChars(env, jEngine, engine);
+    (*env)->ReleaseStringUTFChars(env, jFormat, format);
+
+    return (jint)err;
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_graphviznative_GraphvizModule_nativeStrerror(JNIEnv *env, jclass clazz, jint err) {
+    const char *msg = gv_strerror((gv_error_t)err);
+    return (*env)->NewStringUTF(env, msg ? msg : "Unknown error");
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_graphviznative_GraphvizModule_nativeVersion(JNIEnv *env, jclass clazz) {
+    const char *ver = gv_version();
+    return (*env)->NewStringUTF(env, ver ? ver : "unknown");
+}

package/ios/GraphvizModule.h

@@ -0,0 +1,23 @@
+/*
+ * GraphvizModule.h
+ *
+ * React Native native module for Graphviz rendering.
+ * Supports both old architecture (RCTBridgeModule) and
+ * new architecture (TurboModules) via RCT_NEW_ARCH_ENABLED.
+ *
+ * Licensed under the Apache License, Version 2.0
+ */
+
+#import <React/RCTBridgeModule.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <GraphvizNativeSpec/GraphvizNativeSpec.h>
+#endif
+
+@interface GraphvizModule : NSObject <RCTBridgeModule
+#ifdef RCT_NEW_ARCH_ENABLED
+  , NativeGraphvizNativeSpec
+#endif
+>
+
+@end

package/ios/GraphvizModule.m

@@ -0,0 +1,160 @@
+/*
+ * GraphvizModule.m
+ *
+ * React Native native module implementation for iOS / macOS.
+ * Manages a singleton Graphviz context and dispatches rendering
+ * to a background queue to keep the JS thread responsive.
+ *
+ * Licensed under the Apache License, Version 2.0
+ */
+
+#import "GraphvizModule.h"
+#import "graphviz_api.h"
+
+#import <React/RCTLog.h>
+
+@implementation GraphvizModule {
+    gv_context_t *_context;
+    dispatch_queue_t _renderQueue;
+}
+
+RCT_EXPORT_MODULE(GraphvizNative)
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _renderQueue = dispatch_queue_create("com.graphviznative.render", DISPATCH_QUEUE_SERIAL);
+        _context = NULL;
+    }
+    return self;
+}
+
+- (void)dealloc {
+    if (_context) {
+        gv_context_free(_context);
+        _context = NULL;
+    }
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return NO;
+}
+
+/**
+ * Lazily initializes the Graphviz context on the render queue.
+ * Must be called from within a dispatch to _renderQueue.
+ */
+- (gv_context_t *)ensureContext {
+    if (!_context) {
+        _context = gv_context_new();
+        if (!_context) {
+            RCTLogError(@"GraphvizNative: failed to create Graphviz context");
+        }
+    }
+    return _context;
+}
+
+/**
+ * Map native error codes to JS-friendly error code strings.
+ */
+static NSString *errorCodeToString(gv_error_t err) {
+    switch (err) {
+        case GV_ERR_NULL_INPUT:       return @"NULL_INPUT";
+        case GV_ERR_INVALID_DOT:      return @"INVALID_DOT";
+        case GV_ERR_LAYOUT_FAILED:    return @"LAYOUT_FAILED";
+        case GV_ERR_RENDER_FAILED:    return @"RENDER_FAILED";
+        case GV_ERR_INVALID_ENGINE:   return @"INVALID_ENGINE";
+        case GV_ERR_INVALID_FORMAT:   return @"INVALID_FORMAT";
+        case GV_ERR_OUT_OF_MEMORY:    return @"OUT_OF_MEMORY";
+        case GV_ERR_NOT_INITIALIZED:  return @"NOT_INITIALIZED";
+        default:                      return @"UNKNOWN";
+    }
+}
+
+/**
+ * Returns YES for text-based output formats that do not need base64 encoding.
+ */
+static BOOL isTextFormat(NSString *format) {
+    static NSSet *textFormats;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        textFormats = [NSSet setWithArray:@[@"svg", @"json", @"dot", @"xdot", @"plain"]];
+    });
+    return [textFormats containsObject:format];
+}
+
+RCT_EXPORT_METHOD(renderDot:(NSString *)dot
+                  engine:(NSString *)engine
+                  format:(NSString *)format
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    dispatch_async(_renderQueue, ^{
+        gv_context_t *ctx = [self ensureContext];
+        if (!ctx) {
+            reject(@"NOT_INITIALIZED", @"Failed to initialize Graphviz context", nil);
+            return;
+        }
+
+        char *outData = NULL;
+        size_t outLength = 0;
+
+        gv_error_t err = gv_render(
+            ctx,
+            [dot UTF8String],
+            [engine UTF8String],
+            [format UTF8String],
+            &outData,
+            &outLength
+        );
+
+        if (err != GV_OK) {
+            NSString *code = errorCodeToString(err);
+            NSString *message = [NSString stringWithUTF8String:gv_strerror(err)];
+            reject(code, message, nil);
+            if (outData) {
+                gv_free_render_data(outData);
+            }
+            return;
+        }
+
+        NSString *result;
+        if (isTextFormat(format)) {
+            result = [[NSString alloc] initWithBytes:outData
+                                              length:outLength
+                                            encoding:NSUTF8StringEncoding];
+        } else {
+            NSData *data = [NSData dataWithBytesNoCopy:outData
+                                                length:outLength
+                                          freeWhenDone:NO];
+            result = [data base64EncodedStringWithOptions:0];
+        }
+
+        gv_free_render_data(outData);
+
+        if (!result) {
+            reject(@"RENDER_FAILED", @"Failed to convert render output to string", nil);
+            return;
+        }
+
+        resolve(result);
+    });
+}
+
+RCT_EXPORT_METHOD(getVersion:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    const char *version = gv_version();
+    if (version) {
+        resolve([NSString stringWithUTF8String:version]);
+    } else {
+        reject(@"UNKNOWN", @"Failed to get Graphviz version", nil);
+    }
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+    return std::make_shared<facebook::react::NativeGraphvizNativeSpecJSI>(params);
+}
+#endif
+
+@end

package/ios/GraphvizNative.podspec

@@ -0,0 +1,33 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "GraphvizNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["repository"]["url"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+  s.source       = { :git => package["repository"]["url"], :tag => s.version }
+
+  s.ios.deployment_target = "15.1"
+  s.osx.deployment_target = "11.0"
+
+  s.source_files = "*.{h,m,mm}", "../src/*.{h,c}"
+  s.public_header_files = "GraphvizModule.h"
+
+  # Link against the prebuilt Graphviz static/shared libraries
+  s.preserve_paths = "../third_party/graphviz/**"
+  s.xcconfig = {
+    "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/../src\"",
+    "LIBRARY_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/../third_party/graphviz/lib\"",
+  }
+  s.libraries = "graphviz_api"
+
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-Core"
+  end
+end

package/lib/commonjs/NativeGraphviz.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+/**
+ * TurboModule spec for the Graphviz native module (New Architecture).
+ *
+ * This interface defines the contract between JS and native code.
+ * For the old architecture, we fall back to NativeModules.
+ */
+var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('GraphvizNative');
+//# sourceMappingURL=NativeGraphviz.js.map

package/lib/commonjs/NativeGraphviz.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeGraphviz.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AALA,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAuBeC,gCAAmB,CAACC,YAAY,CAAO,gBAAgB,CAAC","ignoreList":[]}