@kookyleo/graphviz-anywhere-rn 0.1.0

package/scripts/download-native.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+/**
+ * Download prebuilt native libraries for React Native from GitHub Releases.
+ * Runs automatically on `npm install` via postinstall hook.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+
+// Read version from package.json
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '../package.json'), 'utf-8'));
+const version = pkg.version;
+const tag = `v${version}`;
+
+const GITHUB_REPO = 'nicekook/graphviz-anywhere';
+const RELEASE_URL = `https://github.com/${GITHUB_REPO}/releases/download/${tag}`;
+
+const downloads = [
+  {
+    name: 'graphviz-native-ios.tar.gz',
+    dest: path.join(__dirname, '../ios/Frameworks'),
+  },
+  {
+    name: 'graphviz-native-macos-universal.tar.gz',
+    dest: path.join(__dirname, '../macos/Frameworks'),
+  },
+  {
+    name: 'graphviz-native-windows-x86_64.zip',
+    dest: path.join(__dirname, '../windows/Frameworks'),
+  },
+  {
+    name: 'graphviz-native-android-arm64-v8a.tar.gz',
+    dest: path.join(__dirname, '../android/libs/arm64-v8a'),
+  },
+  {
+    name: 'graphviz-native-android-armeabi-v7a.tar.gz',
+    dest: path.join(__dirname, '../android/libs/armeabi-v7a'),
+  },
+  {
+    name: 'graphviz-native-android-x86_64.tar.gz',
+    dest: path.join(__dirname, '../android/libs/x86_64'),
+  },
+];
+
+async function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https.get(url, (response) => {
+      response.pipe(file);
+      file.on('finish', () => {
+        file.close(resolve);
+      });
+    }).on('error', reject);
+  });
+}
+
+async function main() {
+  console.log(`📦 Downloading prebuilt libraries for v${version}...`);
+
+  for (const { name, dest } of downloads) {
+    const url = `${RELEASE_URL}/${name}`;
+    const tempFile = path.join(__dirname, '../../', name);
+
+    try {
+      // Create destination directory
+      fs.mkdirSync(dest, { recursive: true });
+
+      console.log(`  ⬇️  ${name}`);
+
+      // Download
+      await downloadFile(url, tempFile);
+
+      // Extract
+      if (name.endsWith('.tar.gz')) {
+        execSync(`tar -xzf "${tempFile}" -C "${dest}"`, { stdio: 'inherit' });
+      } else if (name.endsWith('.zip')) {
+        execSync(`unzip -o "${tempFile}" -d "${dest}"`, { stdio: 'inherit' });
+      }
+
+      // Cleanup
+      fs.unlinkSync(tempFile);
+      console.log(`  ✓ ${name}`);
+    } catch (error) {
+      console.warn(`  ⚠️  Failed to download ${name}: ${error.message}`);
+      // Continue with other downloads on error
+    }
+  }
+
+  console.log('✨ Done!');
+}
+
+main().catch((error) => {
+  console.error('❌ Error:', error);
+  process.exit(1);
+});

package/src/NativeGraphviz.ts

@@ -0,0 +1,27 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from '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.
+ */
+export interface Spec extends TurboModule {
+  /**
+   * Render a DOT string to the specified format.
+   *
+   * @param dot - DOT language string
+   * @param engine - Layout engine (dot, neato, fdp, sfdp, circo, twopi, osage, patchwork)
+   * @param format - Output format (svg, png, pdf, ps, json, dot, xdot, plain)
+   * @returns Rendered output as a string (base64 for binary formats)
+   */
+  renderDot(dot: string, engine: string, format: string): Promise<string>;
+
+  /**
+   * Get the Graphviz library version string.
+   */
+  getVersion(): Promise<string>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('GraphvizNative');

package/src/index.ts

@@ -0,0 +1,123 @@
+import { NativeModules, Platform } from 'react-native';
+
+const LINKING_ERROR =
+  `The package 'graphviz-anywhere-react-native' doesn't seem to be linked. Make sure:\n\n` +
+  Platform.select({
+    ios: '- You have run `pod install`\n',
+    macos: '- You have run `pod install`\n',
+    android: '',
+    windows: '',
+    default: '',
+  }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+/**
+ * Error codes returned by the native Graphviz module.
+ */
+export const GraphvizErrorCode = {
+  NULL_INPUT: 'NULL_INPUT',
+  INVALID_DOT: 'INVALID_DOT',
+  LAYOUT_FAILED: 'LAYOUT_FAILED',
+  RENDER_FAILED: 'RENDER_FAILED',
+  INVALID_ENGINE: 'INVALID_ENGINE',
+  INVALID_FORMAT: 'INVALID_FORMAT',
+  OUT_OF_MEMORY: 'OUT_OF_MEMORY',
+  NOT_INITIALIZED: 'NOT_INITIALIZED',
+  UNKNOWN: 'UNKNOWN',
+} as const;
+
+export type GraphvizErrorCodeType =
+  (typeof GraphvizErrorCode)[keyof typeof GraphvizErrorCode];
+
+/**
+ * Layout engines supported by Graphviz.
+ */
+export type GraphvizEngine =
+  | 'dot'
+  | 'neato'
+  | 'fdp'
+  | 'sfdp'
+  | 'circo'
+  | 'twopi'
+  | 'osage'
+  | 'patchwork';
+
+/**
+ * Output formats supported by Graphviz.
+ */
+export type GraphvizFormat =
+  | 'svg'
+  | 'png'
+  | 'pdf'
+  | 'ps'
+  | 'json'
+  | 'dot'
+  | 'xdot'
+  | 'plain';
+
+interface NativeGraphvizModule {
+  renderDot(dot: string, engine: string, format: string): Promise<string>;
+  getVersion(): Promise<string>;
+}
+
+/**
+ * Resolve the native module, preferring TurboModules (new arch) with
+ * fallback to the bridge-based NativeModules (old arch).
+ */
+function getNativeModule(): NativeGraphvizModule {
+  // Try TurboModule first (new architecture)
+  try {
+    const turbo = require('./NativeGraphviz').default;
+    if (turbo) {
+      return turbo as NativeGraphvizModule;
+    }
+  } catch {
+    // TurboModules not available, fall through
+  }
+
+  // Fallback to old architecture NativeModules
+  const nativeModule = NativeModules.GraphvizNative;
+  if (!nativeModule) {
+    throw new Error(LINKING_ERROR);
+  }
+  return nativeModule as NativeGraphvizModule;
+}
+
+const GraphvizNative: NativeGraphvizModule = getNativeModule();
+
+/**
+ * Render a DOT language string into the specified output format.
+ *
+ * All rendering is performed on a background thread and the result
+ * is delivered asynchronously via a Promise.
+ *
+ * @param dot - DOT language string describing the graph
+ * @param engine - Layout engine to use (default: "dot")
+ * @param format - Output format (default: "svg")
+ * @returns Promise resolving to the rendered output string.
+ *          For text formats (svg, json, dot, xdot, plain) the raw text is returned.
+ *          For binary formats (png, pdf, ps) the output is base64-encoded.
+ */
+export async function renderDot(
+  dot: string,
+  engine: GraphvizEngine = 'dot',
+  format: GraphvizFormat = 'svg'
+): Promise<string> {
+  return GraphvizNative.renderDot(dot, engine, format);
+}
+
+/**
+ * Get the Graphviz library version string.
+ *
+ * @returns Promise resolving to the version string (e.g. "12.2.1")
+ */
+export async function getVersion(): Promise<string> {
+  return GraphvizNative.getVersion();
+}
+
+export default {
+  renderDot,
+  getVersion,
+  GraphvizErrorCode,
+};

package/windows/GraphvizNative/GraphvizModule.cpp

@@ -0,0 +1,159 @@
+/*
+ * GraphvizModule.cpp (Windows)
+ *
+ * C++/WinRT React Native module implementation for Windows.
+ * Manages a singleton Graphviz context with mutex-protected access.
+ * Promise resolution dispatches work via the thread pool.
+ *
+ * Licensed under the Apache License, Version 2.0
+ */
+
+#include "GraphvizModule.h"
+
+#include <thread>
+#include <cstring>
+
+namespace GraphvizNative {
+
+static const char kBase64Table[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+GraphvizModule::GraphvizModule() : m_context(nullptr) {}
+
+GraphvizModule::~GraphvizModule() {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if (m_context) {
+        gv_context_free(m_context);
+        m_context = nullptr;
+    }
+}
+
+gv_context_t* GraphvizModule::ensureContext() {
+    // Caller must hold m_mutex
+    if (!m_context) {
+        m_context = gv_context_new();
+    }
+    return m_context;
+}
+
+std::string GraphvizModule::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";
+    }
+}
+
+bool GraphvizModule::isTextFormat(const std::string& format) {
+    return format == "svg" ||
+           format == "json" ||
+           format == "dot" ||
+           format == "xdot" ||
+           format == "plain";
+}
+
+std::string GraphvizModule::base64Encode(const char* data, size_t length) {
+    std::string output;
+    size_t olen = 4 * ((length + 2) / 3);
+    output.resize(olen);
+
+    size_t i = 0, j = 0;
+    while (i < length) {
+        uint32_t a = i < length ? static_cast<uint8_t>(data[i++]) : 0;
+        uint32_t b = i < length ? static_cast<uint8_t>(data[i++]) : 0;
+        uint32_t c = i < length ? static_cast<uint8_t>(data[i++]) : 0;
+        uint32_t triple = (a << 16) | (b << 8) | c;
+
+        output[j++] = kBase64Table[(triple >> 18) & 0x3F];
+        output[j++] = kBase64Table[(triple >> 12) & 0x3F];
+        output[j++] = kBase64Table[(triple >> 6) & 0x3F];
+        output[j++] = kBase64Table[triple & 0x3F];
+    }
+
+    size_t mod = length % 3;
+    if (mod == 1) {
+        output[olen - 1] = '=';
+        output[olen - 2] = '=';
+    } else if (mod == 2) {
+        output[olen - 1] = '=';
+    }
+
+    return output;
+}
+
+void GraphvizModule::renderDot(
+    std::string dot,
+    std::string engine,
+    std::string format,
+    React::ReactPromise<std::string> promise) noexcept {
+
+    // Dispatch to a worker thread to avoid blocking the JS thread
+    std::thread([this, dot = std::move(dot), engine = std::move(engine),
+                 format = std::move(format), promise = std::move(promise)]() mutable {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        gv_context_t* ctx = ensureContext();
+        if (!ctx) {
+            promise.Reject(React::ReactError{
+                "NOT_INITIALIZED",
+                "Failed to initialize Graphviz context"
+            });
+            return;
+        }
+
+        char* outData = nullptr;
+        size_t outLength = 0;
+
+        gv_error_t err = gv_render(
+            ctx,
+            dot.c_str(),
+            engine.c_str(),
+            format.c_str(),
+            &outData,
+            &outLength
+        );
+
+        if (err != GV_OK) {
+            std::string code = errorCodeToString(err);
+            const char* msg = gv_strerror(err);
+            promise.Reject(React::ReactError{
+                code,
+                msg ? std::string(msg) : "Unknown error"
+            });
+            if (outData) {
+                gv_free_render_data(outData);
+            }
+            return;
+        }
+
+        std::string result;
+        if (isTextFormat(format)) {
+            result = std::string(outData, outLength);
+        } else {
+            result = base64Encode(outData, outLength);
+        }
+
+        gv_free_render_data(outData);
+        promise.Resolve(result);
+    }).detach();
+}
+
+void GraphvizModule::getVersion(React::ReactPromise<std::string> promise) noexcept {
+    const char* version = gv_version();
+    if (version) {
+        promise.Resolve(std::string(version));
+    } else {
+        promise.Reject(React::ReactError{
+            "UNKNOWN",
+            "Failed to get Graphviz version"
+        });
+    }
+}
+
+} // namespace GraphvizNative

package/windows/GraphvizNative/GraphvizModule.h

@@ -0,0 +1,51 @@
+/*
+ * GraphvizModule.h (Windows)
+ *
+ * C++/WinRT React Native module for Graphviz rendering on Windows.
+ * Uses the react-native-windows native module API.
+ *
+ * Licensed under the Apache License, Version 2.0
+ */
+
+#pragma once
+
+#include <functional>
+#include <string>
+#include <mutex>
+
+#include <NativeModules.h>
+
+extern "C" {
+#include "graphviz_api.h"
+}
+
+namespace GraphvizNative {
+
+REACT_MODULE(GraphvizModule, L"GraphvizNative")
+struct GraphvizModule {
+
+    GraphvizModule();
+    ~GraphvizModule();
+
+    REACT_METHOD(renderDot, L"renderDot")
+    void renderDot(
+        std::string dot,
+        std::string engine,
+        std::string format,
+        React::ReactPromise<std::string> promise) noexcept;
+
+    REACT_METHOD(getVersion, L"getVersion")
+    void getVersion(React::ReactPromise<std::string> promise) noexcept;
+
+private:
+    gv_context_t* ensureContext();
+
+    gv_context_t* m_context;
+    std::mutex m_mutex;
+
+    static std::string errorCodeToString(gv_error_t err);
+    static bool isTextFormat(const std::string& format);
+    static std::string base64Encode(const char* data, size_t length);
+};
+
+} // namespace GraphvizNative

package/windows/GraphvizNative/ReactPackageProvider.cpp

@@ -0,0 +1,20 @@
+/*
+ * ReactPackageProvider.cpp (Windows)
+ *
+ * Registers the GraphvizModule with the React Native Windows runtime.
+ *
+ * Licensed under the Apache License, Version 2.0
+ */
+
+#include "ReactPackageProvider.h"
+
+#include <NativeModules.h>
+
+namespace winrt::GraphvizNative::implementation {
+
+void ReactPackageProvider::CreatePackage(
+    winrt::Microsoft::ReactNative::IReactPackageBuilder const& packageBuilder) noexcept {
+    AddAttributedModules(packageBuilder, true);
+}
+
+} // namespace winrt::GraphvizNative::implementation

package/windows/GraphvizNative/ReactPackageProvider.h

@@ -0,0 +1,21 @@
+/*
+ * ReactPackageProvider.h (Windows)
+ *
+ * Registers the GraphvizModule with the React Native Windows runtime.
+ *
+ * Licensed under the Apache License, Version 2.0
+ */
+
+#pragma once
+
+#include <winrt/Microsoft.ReactNative.h>
+
+namespace winrt::GraphvizNative::implementation {
+
+struct ReactPackageProvider
+    : winrt::implements<ReactPackageProvider, winrt::Microsoft::ReactNative::IReactPackageProvider> {
+
+    void CreatePackage(winrt::Microsoft::ReactNative::IReactPackageBuilder const& packageBuilder) noexcept;
+};
+
+} // namespace winrt::GraphvizNative::implementation