@ohah/hwpjs 0.1.0-rc.1

package/android/stubs/CMakeLists.txt

@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+file(GLOB react_codegen_SRCS CONFIGURE_DEPENDS *.cpp)
+
+add_library(
+  react_codegen_Hwpjs_stub
+  OBJECT
+  ${react_codegen_SRCS}
+)
+
+target_include_directories(react_codegen_Hwpjs_stub PUBLIC .)
+
+target_link_libraries(
+  react_codegen_Hwpjs_stub
+  fbjni
+  jsi
+  # We need to link different libraries based on whether we are building rncore or not, that's necessary
+  # because we want to break a circular dependency between react_codegen_rncore and reactnative
+  reactnative
+)
+
+target_compile_options(
+  react_codegen_Hwpjs_stub
+  PRIVATE
+  -DLOG_TAG=\"Hwpjs\"
+  -fexceptions
+  -frtti
+  -std=c++20
+  -Wall
+)

package/android/stubs/Hwpjs_stub.cpp

@@ -0,0 +1,9 @@
+#include "Hwpjs_stub.h"
+
+namespace facebook::react {
+
+std::shared_ptr<TurboModule> Hwpjs_stub_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params) {
+  return nullptr;
+}
+
+} // namespace facebook::react

package/android/stubs/Hwpjs_stub.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> Hwpjs_stub_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params);
+
+} // namespace facebook::react

package/cpp/CrabyUtils.hpp

@@ -0,0 +1,91 @@
+// Auto generated by Craby. DO NOT EDIT.
+#pragma once
+
+#include "cxx.h"
+#include "ffi.rs.h"
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <vector>
+
+namespace craby {
+namespace hwpjs {
+namespace utils {
+
+class ThreadPool {
+private:
+  bool stop;
+  std::mutex mutex;
+  std::condition_variable condition;
+  std::queue<std::function<void()>> tasks;
+  std::vector<std::thread> workers;
+
+public:
+  ThreadPool(size_t num_threads = 10) : stop(false) {
+    for (size_t i = 0; i < num_threads; ++i) {
+      workers.emplace_back([this] {
+        while (true) {
+          std::function<void()> task;
+
+          {
+            std::unique_lock<std::mutex> lock(this->mutex);
+            this->condition.wait(
+                lock, [this] { return this->stop || !this->tasks.empty(); });
+
+            if (this->stop && this->tasks.empty()) {
+              return;
+            }
+
+            task = std::move(this->tasks.front());
+            this->tasks.pop();
+          }
+
+          task();
+        }
+      });
+    }
+  }
+
+  template <class F> void enqueue(F &&f) {
+    {
+      std::unique_lock<std::mutex> lock(mutex);
+      if (stop) {
+        return;
+      }
+      tasks.emplace(std::forward<F>(f));
+    }
+    condition.notify_one();
+  }
+
+  void shutdown() {
+    {
+      std::unique_lock<std::mutex> lock(mutex);
+      stop = true;
+      std::queue<std::function<void()>> empty;
+      std::swap(tasks, empty);
+    }
+
+    condition.notify_all();
+
+    for (std::thread &worker : workers) {
+      if (worker.joinable()) {
+        worker.join();
+      }
+    }
+  }
+
+  ~ThreadPool() {
+    shutdown();
+  }
+};
+
+inline std::string errorMessage(const std::exception &err) {
+  const auto* rs_err = dynamic_cast<const rust::Error*>(&err);
+  return std::string(rs_err ? rs_err->what() : err.what());
+}
+
+} // namespace utils
+} // namespace hwpjs
+} // namespace craby

package/cpp/CxxHwpjsModule.cpp

@@ -0,0 +1,125 @@
+// Auto generated by Craby. DO NOT EDIT.
+#include "CxxHwpjsModule.hpp"
+#include "cxx.h"
+#include "bridging-generated.hpp"
+#include <react/bridging/Bridging.h>
+
+using namespace facebook;
+
+namespace craby {
+namespace hwpjs {
+namespace modules {
+
+std::string CxxHwpjsModule::dataPath = std::string();
+
+CxxHwpjsModule::CxxHwpjsModule(
+    std::shared_ptr<react::CallInvoker> jsInvoker)
+    : TurboModule(CxxHwpjsModule::kModuleName, jsInvoker) {
+  // No signals
+  callInvoker_ = std::move(jsInvoker);
+  module_ = std::shared_ptr<craby::hwpjs::bridging::Hwpjs>(
+    craby::hwpjs::bridging::createHwpjs(
+      reinterpret_cast<uintptr_t>(this),
+      rust::Str(dataPath.data(), dataPath.size())).into_raw(),
+    [](craby::hwpjs::bridging::Hwpjs *ptr) { rust::Box<craby::hwpjs::bridging::Hwpjs>::from_raw(ptr); }
+  );
+  threadPool_ = std::make_shared<craby::hwpjs::utils::ThreadPool>(10);
+  methodMap_["fileHeader"] = MethodMetadata{1, &CxxHwpjsModule::fileHeader};
+  methodMap_["toJson"] = MethodMetadata{1, &CxxHwpjsModule::toJson};
+  methodMap_["toMarkdown"] = MethodMetadata{2, &CxxHwpjsModule::toMarkdown};
+}
+
+CxxHwpjsModule::~CxxHwpjsModule() {
+  invalidate();
+}
+
+void CxxHwpjsModule::invalidate() {
+  if (invalidated_.exchange(true)) {
+    return;
+  }
+
+  invalidated_.store(true);
+  listenersMap_.clear();
+
+  // No signals
+
+  // Shutdown thread pool
+  threadPool_->shutdown();
+}
+
+jsi::Value CxxHwpjsModule::fileHeader(jsi::Runtime &rt,
+                                react::TurboModule &turboModule,
+                                const jsi::Value args[],
+                                size_t count) {
+  auto &thisModule = static_cast<CxxHwpjsModule &>(turboModule);
+  auto callInvoker = thisModule.callInvoker_;
+  auto it_ = thisModule.module_;
+
+  try {
+    if (1 != count) {
+      throw jsi::JSError(rt, "Expected 1 argument");
+    }
+
+    auto arg0 = react::bridging::fromJs<rust::Vec<double>>(rt, args[0], callInvoker);
+    auto ret = craby::hwpjs::bridging::fileHeader(*it_, arg0);
+
+    return react::bridging::toJs(rt, ret);
+  } catch (const jsi::JSError &err) {
+    throw err;
+  } catch (const std::exception &err) {
+    throw jsi::JSError(rt, craby::hwpjs::utils::errorMessage(err));
+  }
+}
+
+jsi::Value CxxHwpjsModule::toJson(jsi::Runtime &rt,
+                                react::TurboModule &turboModule,
+                                const jsi::Value args[],
+                                size_t count) {
+  auto &thisModule = static_cast<CxxHwpjsModule &>(turboModule);
+  auto callInvoker = thisModule.callInvoker_;
+  auto it_ = thisModule.module_;
+
+  try {
+    if (1 != count) {
+      throw jsi::JSError(rt, "Expected 1 argument");
+    }
+
+    auto arg0 = react::bridging::fromJs<rust::Vec<double>>(rt, args[0], callInvoker);
+    auto ret = craby::hwpjs::bridging::toJson(*it_, arg0);
+
+    return react::bridging::toJs(rt, ret);
+  } catch (const jsi::JSError &err) {
+    throw err;
+  } catch (const std::exception &err) {
+    throw jsi::JSError(rt, craby::hwpjs::utils::errorMessage(err));
+  }
+}
+
+jsi::Value CxxHwpjsModule::toMarkdown(jsi::Runtime &rt,
+                                react::TurboModule &turboModule,
+                                const jsi::Value args[],
+                                size_t count) {
+  auto &thisModule = static_cast<CxxHwpjsModule &>(turboModule);
+  auto callInvoker = thisModule.callInvoker_;
+  auto it_ = thisModule.module_;
+
+  try {
+    if (2 != count) {
+      throw jsi::JSError(rt, "Expected 2 arguments");
+    }
+
+    auto arg0 = react::bridging::fromJs<rust::Vec<double>>(rt, args[0], callInvoker);
+    auto arg1 = react::bridging::fromJs<craby::hwpjs::bridging::ToMarkdownOptions>(rt, args[1], callInvoker);
+    auto ret = craby::hwpjs::bridging::toMarkdown(*it_, arg0, arg1);
+
+    return react::bridging::toJs(rt, ret);
+  } catch (const jsi::JSError &err) {
+    throw err;
+  } catch (const std::exception &err) {
+    throw jsi::JSError(rt, craby::hwpjs::utils::errorMessage(err));
+  }
+}
+
+} // namespace modules
+} // namespace hwpjs
+} // namespace craby

package/cpp/CxxHwpjsModule.hpp

@@ -0,0 +1,53 @@
+// Auto generated by Craby. DO NOT EDIT.
+#pragma once
+
+#include "CrabyUtils.hpp"
+#include "ffi.rs.h"
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace craby {
+namespace hwpjs {
+namespace modules {
+
+class JSI_EXPORT CxxHwpjsModule : public facebook::react::TurboModule {
+public:
+  static constexpr const char *kModuleName = "Hwpjs";
+  static std::string dataPath;
+
+  CxxHwpjsModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+  ~CxxHwpjsModule();
+
+  void invalidate();
+  static facebook::jsi::Value
+  fileHeader(facebook::jsi::Runtime &rt,
+      facebook::react::TurboModule &turboModule,
+      const facebook::jsi::Value args[], size_t count);
+
+  static facebook::jsi::Value
+  toJson(facebook::jsi::Runtime &rt,
+      facebook::react::TurboModule &turboModule,
+      const facebook::jsi::Value args[], size_t count);
+
+  static facebook::jsi::Value
+  toMarkdown(facebook::jsi::Runtime &rt,
+      facebook::react::TurboModule &turboModule,
+      const facebook::jsi::Value args[], size_t count);
+
+protected:
+  std::shared_ptr<facebook::react::CallInvoker> callInvoker_;
+  std::shared_ptr<craby::hwpjs::bridging::Hwpjs> module_;
+  std::atomic<bool> invalidated_{false};
+  std::atomic<size_t> nextListenerId_{0};
+  std::mutex listenersMutex_;
+  std::unordered_map<
+    std::string,
+    std::unordered_map<size_t, std::shared_ptr<facebook::jsi::Function>>>
+    listenersMap_;
+  std::shared_ptr<craby::hwpjs::utils::ThreadPool> threadPool_;
+};
+
+} // namespace modules
+} // namespace hwpjs
+} // namespace craby

package/cpp/bridging-generated.hpp

@@ -0,0 +1,158 @@
+// Auto generated by Craby. DO NOT EDIT.
+#pragma once
+
+#include "cxx.h"
+#include "ffi.rs.h"
+#include <react/bridging/Bridging.h>
+
+using namespace facebook;
+
+namespace facebook {
+namespace react {
+
+template <>
+struct Bridging<rust::Str> {
+  static rust::Str fromJs(jsi::Runtime& rt, const jsi::Value &value, std::shared_ptr<CallInvoker> callInvoker) {
+    auto str = value.asString(rt).utf8(rt);
+    return rust::Str(str.data(), str.size());
+  }
+
+  static jsi::Value toJs(jsi::Runtime& rt, const rust::Str& value) {
+    return react::bridging::toJs(rt, std::string(value.data(), value.size()));
+  }
+};
+
+template <>
+struct Bridging<rust::String> {
+  static rust::String fromJs(jsi::Runtime& rt, const jsi::Value &value, std::shared_ptr<CallInvoker> callInvoker) {
+    auto str = value.asString(rt).utf8(rt);
+    return rust::String(str.data(), str.size());
+  }
+
+  static jsi::Value toJs(jsi::Runtime& rt, const rust::String& value) {
+    return react::bridging::toJs(rt, std::string(value.data(), value.size()));
+  }
+};
+
+template <typename T>
+struct Bridging<rust::Vec<T>> {
+  static rust::Vec<T> fromJs(jsi::Runtime& rt, const jsi::Value &value, std::shared_ptr<CallInvoker> callInvoker) {
+    auto arr = value.asObject(rt).asArray(rt);
+    size_t len = arr.length(rt);
+    rust::Vec<T> vec;
+    vec.reserve(len);
+
+    for (size_t i = 0; i < len; i++) {
+      auto element = arr.getValueAtIndex(rt, i);
+      vec.push_back(react::bridging::fromJs<T>(rt, element, callInvoker));
+    }
+
+    return vec;
+  }
+
+  static jsi::Array toJs(jsi::Runtime& rt, const rust::Vec<T>& vec) {
+    auto arr = jsi::Array(rt, vec.size());
+
+    for (size_t i = 0; i < vec.size(); i++) {
+      auto jsElement = react::bridging::toJs(rt, vec[i]);
+      arr.setValueAtIndex(rt, i, jsElement);
+    }
+
+    return arr;
+  }
+};
+
+template <>
+struct Bridging<craby::hwpjs::bridging::NullableString> {
+  static craby::hwpjs::bridging::NullableString fromJs(jsi::Runtime &rt, const jsi::Value& value, std::shared_ptr<CallInvoker> callInvoker) {
+    if (value.isNull()) {
+      return craby::hwpjs::bridging::NullableString{true, rust::String()};
+    }
+
+    auto val = react::bridging::fromJs<rust::String>(rt, value, callInvoker);
+    auto ret = craby::hwpjs::bridging::NullableString{false, val};
+
+    return ret;
+  }
+
+  static jsi::Value toJs(jsi::Runtime &rt, craby::hwpjs::bridging::NullableString value) {
+    if (value.null) {
+      return jsi::Value::null();
+    }
+
+    return react::bridging::toJs(rt, value.val);
+  }
+};
+
+template <>
+struct Bridging<craby::hwpjs::bridging::ToMarkdownOptions> {
+  static craby::hwpjs::bridging::ToMarkdownOptions fromJs(jsi::Runtime &rt, const jsi::Value& value, std::shared_ptr<CallInvoker> callInvoker) {
+    auto obj = value.asObject(rt);
+    auto obj$imageOutputDir = obj.getProperty(rt, "imageOutputDir");
+    auto obj$image = obj.getProperty(rt, "image");
+    auto obj$useHtml = obj.getProperty(rt, "useHtml");
+    auto obj$includeVersion = obj.getProperty(rt, "includeVersion");
+    auto obj$includePageInfo = obj.getProperty(rt, "includePageInfo");
+
+    auto _obj$imageOutputDir = react::bridging::fromJs<craby::hwpjs::bridging::NullableString>(rt, obj$imageOutputDir, callInvoker);
+    auto _obj$image = react::bridging::fromJs<craby::hwpjs::bridging::NullableString>(rt, obj$image, callInvoker);
+    auto _obj$useHtml = react::bridging::fromJs<bool>(rt, obj$useHtml, callInvoker);
+    auto _obj$includeVersion = react::bridging::fromJs<bool>(rt, obj$includeVersion, callInvoker);
+    auto _obj$includePageInfo = react::bridging::fromJs<bool>(rt, obj$includePageInfo, callInvoker);
+
+    craby::hwpjs::bridging::ToMarkdownOptions ret = {
+      _obj$imageOutputDir,
+      _obj$image,
+      _obj$useHtml,
+      _obj$includeVersion,
+      _obj$includePageInfo
+    };
+
+    return ret;
+  }
+
+  static jsi::Value toJs(jsi::Runtime &rt, craby::hwpjs::bridging::ToMarkdownOptions value) {
+    jsi::Object obj = jsi::Object(rt);
+    auto _obj$imageOutputDir = react::bridging::toJs(rt, value.image_output_dir);
+    auto _obj$image = react::bridging::toJs(rt, value.image);
+    auto _obj$useHtml = react::bridging::toJs(rt, value.use_html);
+    auto _obj$includeVersion = react::bridging::toJs(rt, value.include_version);
+    auto _obj$includePageInfo = react::bridging::toJs(rt, value.include_page_info);
+
+    obj.setProperty(rt, "imageOutputDir", _obj$imageOutputDir);
+    obj.setProperty(rt, "image", _obj$image);
+    obj.setProperty(rt, "useHtml", _obj$useHtml);
+    obj.setProperty(rt, "includeVersion", _obj$includeVersion);
+    obj.setProperty(rt, "includePageInfo", _obj$includePageInfo);
+
+    return jsi::Value(rt, obj);
+  }
+};
+
+template <>
+struct Bridging<craby::hwpjs::bridging::ToMarkdownResult> {
+  static craby::hwpjs::bridging::ToMarkdownResult fromJs(jsi::Runtime &rt, const jsi::Value& value, std::shared_ptr<CallInvoker> callInvoker) {
+    auto obj = value.asObject(rt);
+    auto obj$markdown = obj.getProperty(rt, "markdown");
+
+    auto _obj$markdown = react::bridging::fromJs<rust::String>(rt, obj$markdown, callInvoker);
+
+    craby::hwpjs::bridging::ToMarkdownResult ret = {
+      _obj$markdown
+    };
+
+    return ret;
+  }
+
+  static jsi::Value toJs(jsi::Runtime &rt, craby::hwpjs::bridging::ToMarkdownResult value) {
+    jsi::Object obj = jsi::Object(rt);
+    auto _obj$markdown = react::bridging::toJs(rt, value.markdown);
+
+    obj.setProperty(rt, "markdown", _obj$markdown);
+
+    return jsi::Value(rt, obj);
+  }
+};
+
+} // namespace react
+} // namespace facebook

package/dist/browser.js

@@ -0,0 +1 @@
+export * from '@ohah/hwpjs-wasm32-wasi'

package/dist/hwpjs-napi.wasi-browser.js

@@ -0,0 +1,61 @@
+import {
+  createOnMessage as __wasmCreateOnMessageForFsProxy,
+  getDefaultContext as __emnapiGetDefaultContext,
+  instantiateNapiModuleSync as __emnapiInstantiateNapiModuleSync,
+  WASI as __WASI,
+} from '@napi-rs/wasm-runtime'
+
+
+
+const __wasi = new __WASI({
+  version: 'preview1',
+})
+
+const __wasmUrl = new URL('./hwpjs-napi.wasm32-wasi.wasm', import.meta.url).href
+const __emnapiContext = __emnapiGetDefaultContext()
+
+
+const __sharedMemory = new WebAssembly.Memory({
+  initial: 4000,
+  maximum: 65536,
+  shared: true,
+})
+
+const __wasmFile = await fetch(__wasmUrl).then((res) => res.arrayBuffer())
+
+const {
+  instance: __napiInstance,
+  module: __wasiModule,
+  napiModule: __napiModule,
+} = __emnapiInstantiateNapiModuleSync(__wasmFile, {
+  context: __emnapiContext,
+  asyncWorkPoolSize: 4,
+  wasi: __wasi,
+  onCreateWorker() {
+    const worker = new Worker(new URL('./wasi-worker-browser.mjs', import.meta.url), {
+      type: 'module',
+    })
+
+    return worker
+  },
+  overwriteImports(importObject) {
+    importObject.env = {
+      ...importObject.env,
+      ...importObject.napi,
+      ...importObject.emnapi,
+      memory: __sharedMemory,
+    }
+    return importObject
+  },
+  beforeInit({ instance }) {
+    for (const name of Object.keys(instance.exports)) {
+      if (name.startsWith('__napi_register__')) {
+        instance.exports[name]()
+      }
+    }
+  },
+})
+export default __napiModule.exports
+export const fileHeader = __napiModule.exports.fileHeader
+export const toJson = __napiModule.exports.toJson
+export const toMarkdown = __napiModule.exports.toMarkdown

package/dist/hwpjs-napi.wasi.cjs

@@ -0,0 +1,113 @@
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const __nodeFs = require('node:fs')
+const __nodePath = require('node:path')
+const { WASI: __nodeWASI } = require('node:wasi')
+const { Worker } = require('node:worker_threads')
+
+const {
+  createOnMessage: __wasmCreateOnMessageForFsProxy,
+  getDefaultContext: __emnapiGetDefaultContext,
+  instantiateNapiModuleSync: __emnapiInstantiateNapiModuleSync,
+} = require('@napi-rs/wasm-runtime')
+
+const __rootDir = __nodePath.parse(process.cwd()).root
+
+const __wasi = new __nodeWASI({
+  version: 'preview1',
+  env: process.env,
+  preopens: {
+    [__rootDir]: __rootDir,
+  }
+})
+
+const __emnapiContext = __emnapiGetDefaultContext()
+
+const __sharedMemory = new WebAssembly.Memory({
+  initial: 4000,
+  maximum: 65536,
+  shared: true,
+})
+
+let __wasmFilePath = __nodePath.join(__dirname, 'hwpjs-napi.wasm32-wasi.wasm')
+const __wasmDebugFilePath = __nodePath.join(__dirname, 'hwpjs-napi.wasm32-wasi.debug.wasm')
+
+if (__nodeFs.existsSync(__wasmDebugFilePath)) {
+  __wasmFilePath = __wasmDebugFilePath
+} else if (!__nodeFs.existsSync(__wasmFilePath)) {
+  try {
+    __wasmFilePath = __nodePath.resolve('@ohah/hwpjs-wasm32-wasi')
+  } catch {
+    throw new Error('Cannot find hwpjs-napi.wasm32-wasi.wasm file, and @ohah/hwpjs-wasm32-wasi package is not installed.')
+  }
+}
+
+const { instance: __napiInstance, module: __wasiModule, napiModule: __napiModule } = __emnapiInstantiateNapiModuleSync(__nodeFs.readFileSync(__wasmFilePath), {
+  context: __emnapiContext,
+  asyncWorkPoolSize: (function() {
+    const threadsSizeFromEnv = Number(process.env.NAPI_RS_ASYNC_WORK_POOL_SIZE ?? process.env.UV_THREADPOOL_SIZE)
+    // NaN > 0 is false
+    if (threadsSizeFromEnv > 0) {
+      return threadsSizeFromEnv
+    } else {
+      return 4
+    }
+  })(),
+  reuseWorker: true,
+  wasi: __wasi,
+  onCreateWorker() {
+    const worker = new Worker(__nodePath.join(__dirname, 'wasi-worker.mjs'), {
+      env: process.env,
+    })
+    worker.onmessage = ({ data }) => {
+      __wasmCreateOnMessageForFsProxy(__nodeFs)(data)
+    }
+
+    // The main thread of Node.js waits for all the active handles before exiting.
+    // But Rust threads are never waited without `thread::join`.
+    // So here we hack the code of Node.js to prevent the workers from being referenced (active).
+    // According to https://github.com/nodejs/node/blob/19e0d472728c79d418b74bddff588bea70a403d0/lib/internal/worker.js#L415,
+    // a worker is consist of two handles: kPublicPort and kHandle.
+    {
+      const kPublicPort = Object.getOwnPropertySymbols(worker).find(s =>
+        s.toString().includes("kPublicPort")
+      );
+      if (kPublicPort) {
+        worker[kPublicPort].ref = () => {};
+      }
+
+      const kHandle = Object.getOwnPropertySymbols(worker).find(s =>
+        s.toString().includes("kHandle")
+      );
+      if (kHandle) {
+        worker[kHandle].ref = () => {};
+      }
+
+      worker.unref();
+    }
+    return worker
+  },
+  overwriteImports(importObject) {
+    importObject.env = {
+      ...importObject.env,
+      ...importObject.napi,
+      ...importObject.emnapi,
+      memory: __sharedMemory,
+    }
+    return importObject
+  },
+  beforeInit({ instance }) {
+    for (const name of Object.keys(instance.exports)) {
+      if (name.startsWith('__napi_register__')) {
+        instance.exports[name]()
+      }
+    }
+  },
+})
+module.exports = __napiModule.exports
+module.exports.fileHeader = __napiModule.exports.fileHeader
+module.exports.toJson = __napiModule.exports.toJson
+module.exports.toMarkdown = __napiModule.exports.toMarkdown