react-native-jieba 0.1.0

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest />

package/android/src/main/java/com/jieba/JiebaAndroidHelperModule.kt

@@ -0,0 +1,48 @@
+package com.jieba
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import java.io.File
+import java.io.FileOutputStream
+
+@ReactModule(name = JiebaAndroidHelperModule.NAME)
+class JiebaAndroidHelperModule(reactContext: ReactApplicationContext) :
+  NativeJiebaAndroidHelperSpec(reactContext) {
+
+  override fun getName(): String = NAME
+
+  override fun prepareDictDir(promise: Promise) {
+    val context = reactApplicationContext
+    Thread {
+      try {
+        val dictDir = File(context.filesDir, DICT_DIR_NAME)
+        if (!dictDir.exists()) dictDir.mkdirs()
+        for (filename in DICT_FILES) {
+          val target = File(dictDir, filename)
+          if (target.exists() && target.length() > 0) continue
+          context.assets.open(filename).use { input ->
+            FileOutputStream(target).use { output ->
+              input.copyTo(output)
+            }
+          }
+        }
+        promise.resolve(dictDir.absolutePath)
+      } catch (t: Throwable) {
+        promise.reject("E_JIEBA_DICT_EXTRACT", t.message, t)
+      }
+    }.start()
+  }
+
+  companion object {
+    const val NAME = "JiebaAndroidHelper"
+    private const val DICT_DIR_NAME = "jieba-dict"
+    private val DICT_FILES = arrayOf(
+      "jieba.dict.utf8",
+      "hmm_model.utf8",
+      "user.dict.utf8",
+      "idf.utf8",
+      "stop_words.utf8",
+    )
+  }
+}

package/android/src/main/java/com/jieba/JiebaPackage.kt

@@ -0,0 +1,32 @@
+package com.jieba
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class JiebaPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == JiebaAndroidHelperModule.NAME) {
+      JiebaAndroidHelperModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      mapOf(
+        JiebaAndroidHelperModule.NAME to ReactModuleInfo(
+          JiebaAndroidHelperModule.NAME,
+          JiebaAndroidHelperModule::class.java.name,
+          false,
+          false,
+          false,
+          true,
+        )
+      )
+    }
+  }
+}

package/cpp/JiebaImpl.cpp

@@ -0,0 +1,154 @@
+#include "JiebaImpl.h"
+
+#include <cppjieba/Jieba.hpp>
+
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace facebook::react {
+
+namespace {
+
+std::mutex& dictMutex() {
+  static std::mutex m;
+  return m;
+}
+
+std::string& dictPathStorage() {
+  static std::string p;
+  return p;
+}
+
+std::unique_ptr<cppjieba::Jieba>& jiebaStorage() {
+  static std::unique_ptr<cppjieba::Jieba> j;
+  return j;
+}
+
+std::string joinPath(const std::string& dir, const std::string& filename) {
+  if (dir.empty()) return filename;
+  char last = dir[dir.size() - 1];
+  if (last == '/' || last == '\\') return dir + filename;
+  return dir + "/" + filename;
+}
+
+jsi::Array stringVectorToArray(jsi::Runtime& rt, const std::vector<std::string>& words) {
+  jsi::Array arr(rt, words.size());
+  for (size_t i = 0; i < words.size(); ++i) {
+    arr.setValueAtIndex(rt, i, jsi::String::createFromUtf8(rt, words[i]));
+  }
+  return arr;
+}
+
+}
+
+JiebaImpl::JiebaImpl(
+  std::shared_ptr<CallInvoker> jsInvoker
+)
+  : NativeJiebaCxxSpec(std::move(jsInvoker)) {}
+
+void JiebaImpl::setDictPathFromNative(const std::string& dictPath) {
+  std::lock_guard<std::mutex> lock(dictMutex());
+  if (dictPathStorage() != dictPath) {
+    dictPathStorage() = dictPath;
+    jiebaStorage().reset();
+  }
+}
+
+void JiebaImpl::setDictPath(jsi::Runtime& rt, jsi::String path) {
+  setDictPathFromNative(path.utf8(rt));
+}
+
+cppjieba::Jieba& JiebaImpl::getJieba() {
+  std::lock_guard<std::mutex> lock(dictMutex());
+  if (!jiebaStorage()) {
+    const std::string& base = dictPathStorage();
+    if (base.empty()) {
+      throw std::runtime_error(
+        "react-native-jieba: dictionary path not set. "
+        "The native module failed to locate bundled dict files."
+      );
+    }
+    jiebaStorage() = std::make_unique<cppjieba::Jieba>(
+      joinPath(base, "jieba.dict.utf8"),
+      joinPath(base, "hmm_model.utf8"),
+      joinPath(base, "user.dict.utf8"),
+      joinPath(base, "idf.utf8"),
+      joinPath(base, "stop_words.utf8")
+    );
+  }
+  return *jiebaStorage();
+}
+
+jsi::Array JiebaImpl::cut(jsi::Runtime& rt, jsi::String sentence, bool hmm) {
+  std::vector<std::string> words;
+  getJieba().Cut(sentence.utf8(rt), words, hmm);
+  return stringVectorToArray(rt, words);
+}
+
+jsi::Array JiebaImpl::cutAll(jsi::Runtime& rt, jsi::String sentence) {
+  std::vector<std::string> words;
+  getJieba().CutAll(sentence.utf8(rt), words);
+  return stringVectorToArray(rt, words);
+}
+
+jsi::Array JiebaImpl::cutForSearch(jsi::Runtime& rt, jsi::String sentence, bool hmm) {
+  std::vector<std::string> words;
+  getJieba().CutForSearch(sentence.utf8(rt), words, hmm);
+  return stringVectorToArray(rt, words);
+}
+
+jsi::Array JiebaImpl::cutHMM(jsi::Runtime& rt, jsi::String sentence) {
+  std::vector<std::string> words;
+  getJieba().CutHMM(sentence.utf8(rt), words);
+  return stringVectorToArray(rt, words);
+}
+
+jsi::Array JiebaImpl::cutSmall(jsi::Runtime& rt, jsi::String sentence, double maxWordLen) {
+  std::vector<std::string> words;
+  size_t maxLen = maxWordLen <= 0 ? 0 : static_cast<size_t>(maxWordLen);
+  getJieba().CutSmall(sentence.utf8(rt), words, maxLen);
+  return stringVectorToArray(rt, words);
+}
+
+jsi::Array JiebaImpl::tag(jsi::Runtime& rt, jsi::String sentence) {
+  std::vector<std::pair<std::string, std::string>> tagged;
+  getJieba().Tag(sentence.utf8(rt), tagged);
+  jsi::Array arr(rt, tagged.size());
+  for (size_t i = 0; i < tagged.size(); ++i) {
+    jsi::Object obj(rt);
+    obj.setProperty(rt, "word", jsi::String::createFromUtf8(rt, tagged[i].first));
+    obj.setProperty(rt, "tag", jsi::String::createFromUtf8(rt, tagged[i].second));
+    arr.setValueAtIndex(rt, i, std::move(obj));
+  }
+  return arr;
+}
+
+jsi::Array JiebaImpl::extract(jsi::Runtime& rt, jsi::String sentence, double topK) {
+  std::vector<cppjieba::KeywordExtractor::Word> keywords;
+  size_t n = topK <= 0 ? 5 : static_cast<size_t>(topK);
+  getJieba().extractor.Extract(sentence.utf8(rt), keywords, n);
+  jsi::Array arr(rt, keywords.size());
+  for (size_t i = 0; i < keywords.size(); ++i) {
+    jsi::Object obj(rt);
+    obj.setProperty(rt, "word", jsi::String::createFromUtf8(rt, keywords[i].word));
+    obj.setProperty(rt, "weight", jsi::Value(keywords[i].weight));
+    arr.setValueAtIndex(rt, i, std::move(obj));
+  }
+  return arr;
+}
+
+bool JiebaImpl::insertUserWord(jsi::Runtime& rt, jsi::String word, jsi::String tag) {
+  std::string t = tag.utf8(rt);
+  if (t.empty()) t = cppjieba::UNKNOWN_TAG;
+  return getJieba().InsertUserWord(word.utf8(rt), t);
+}
+
+bool JiebaImpl::find(jsi::Runtime& rt, jsi::String word) {
+  return getJieba().Find(word.utf8(rt));
+}
+
+}

package/cpp/JiebaImpl.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <JiebaSpecJSI.h>
+
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace cppjieba {
+class Jieba;
+}
+
+namespace facebook::react {
+
+class JiebaImpl
+  : public NativeJiebaCxxSpec<JiebaImpl> {
+public:
+  JiebaImpl(std::shared_ptr<CallInvoker> jsInvoker);
+
+  static void setDictPathFromNative(const std::string& dictPath);
+
+  void setDictPath(jsi::Runtime& rt, jsi::String path);
+  jsi::Array cut(jsi::Runtime& rt, jsi::String sentence, bool hmm);
+  jsi::Array cutAll(jsi::Runtime& rt, jsi::String sentence);
+  jsi::Array cutForSearch(jsi::Runtime& rt, jsi::String sentence, bool hmm);
+  jsi::Array cutHMM(jsi::Runtime& rt, jsi::String sentence);
+  jsi::Array cutSmall(jsi::Runtime& rt, jsi::String sentence, double maxWordLen);
+  jsi::Array tag(jsi::Runtime& rt, jsi::String sentence);
+  jsi::Array extract(jsi::Runtime& rt, jsi::String sentence, double topK);
+  bool insertUserWord(jsi::Runtime& rt, jsi::String word, jsi::String tag);
+  bool find(jsi::Runtime& rt, jsi::String word);
+
+private:
+  cppjieba::Jieba& getJieba();
+};
+
+}

package/cpp/cppjieba/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/cpp/cppjieba/deps/limonp/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/cpp/cppjieba/deps/limonp/include/limonp/ArgvContext.hpp

@@ -0,0 +1,70 @@
+/************************************
+ * file enc : ascii
+ * author   : wuyanyi09@gmail.com
+ ************************************/
+
+#ifndef LIMONP_ARGV_FUNCTS_H
+#define LIMONP_ARGV_FUNCTS_H
+
+#include <set>
+#include <sstream>
+#include "StringUtil.hpp"
+
+namespace limonp {
+
+using namespace std;
+
+class ArgvContext {
+ public :
+  ArgvContext(int argc, const char* const * argv) {
+    for(int i = 0; i < argc; i++) {
+      if(StartsWith(argv[i], "-")) {
+        if(i + 1 < argc && !StartsWith(argv[i + 1], "-")) {
+          mpss_[argv[i]] = argv[i+1];
+          i++;
+        } else {
+          sset_.insert(argv[i]);
+        }
+      } else {
+        args_.push_back(argv[i]);
+      }
+    }
+  }
+  ~ArgvContext() {
+  }
+
+  friend ostream& operator << (ostream& os, const ArgvContext& args);
+  string operator [](size_t i) const {
+    if(i < args_.size()) {
+      return args_[i];
+    }
+    return "";
+  }
+  string operator [](const string& key) const {
+    map<string, string>::const_iterator it = mpss_.find(key);
+    if(it != mpss_.end()) {
+      return it->second;
+    }
+    return "";
+  }
+
+  bool HasKey(const string& key) const {
+    if(mpss_.find(key) != mpss_.end() || sset_.find(key) != sset_.end()) {
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  vector<string> args_;
+  map<string, string> mpss_;
+  set<string> sset_;
+}; // class ArgvContext
+
+inline ostream& operator << (ostream& os, const ArgvContext& args) {
+  return os<<args.args_<<args.mpss_<<args.sset_;
+}
+
+} // namespace limonp
+
+#endif

package/cpp/cppjieba/deps/limonp/include/limonp/Closure.hpp

@@ -0,0 +1,206 @@
+#ifndef LIMONP_CLOSURE_HPP
+#define LIMONP_CLOSURE_HPP
+
+namespace limonp {
+
+class ClosureInterface {
+ public:
+  virtual ~ClosureInterface() {
+  }
+  virtual void Run() = 0;
+};
+
+template <class Funct>
+class Closure0: public ClosureInterface {
+ public:
+  Closure0(Funct fun) {
+    fun_ = fun;
+  }
+  virtual ~Closure0() {
+  }
+  virtual void Run() {
+    (*fun_)();
+  }
+ private:
+  Funct fun_;
+}; 
+
+template <class Funct, class Arg1>
+class Closure1: public ClosureInterface {
+ public:
+  Closure1(Funct fun, Arg1 arg1) {
+    fun_ = fun;
+    arg1_ = arg1;
+  }
+  virtual ~Closure1() {
+  }
+  virtual void Run() {
+    (*fun_)(arg1_);
+  }
+ private:
+  Funct fun_;
+  Arg1 arg1_;
+}; 
+
+template <class Funct, class Arg1, class Arg2>
+class Closure2: public ClosureInterface {
+ public:
+  Closure2(Funct fun, Arg1 arg1, Arg2 arg2) {
+    fun_ = fun;
+    arg1_ = arg1;
+    arg2_ = arg2;
+  }
+  virtual ~Closure2() {
+  }
+  virtual void Run() {
+    (*fun_)(arg1_, arg2_);
+  }
+ private:
+  Funct fun_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+}; 
+
+template <class Funct, class Arg1, class Arg2, class Arg3>
+class Closure3: public ClosureInterface {
+ public:
+  Closure3(Funct fun, Arg1 arg1, Arg2 arg2, Arg3 arg3) {
+    fun_ = fun;
+    arg1_ = arg1;
+    arg2_ = arg2;
+    arg3_ = arg3;
+  }
+  virtual ~Closure3() {
+  }
+  virtual void Run() {
+    (*fun_)(arg1_, arg2_, arg3_);
+  }
+ private:
+  Funct fun_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+  Arg3 arg3_;
+}; 
+
+template <class Obj, class Funct> 
+class ObjClosure0: public ClosureInterface {
+ public:
+  ObjClosure0(Obj* p, Funct fun) {
+   p_ = p;
+   fun_ = fun;
+  }
+  virtual ~ObjClosure0() {
+  }
+  virtual void Run() {
+    (p_->*fun_)();
+  }
+ private:
+  Obj* p_;
+  Funct fun_;
+}; 
+
+template <class Obj, class Funct, class Arg1> 
+class ObjClosure1: public ClosureInterface {
+ public:
+  ObjClosure1(Obj* p, Funct fun, Arg1 arg1) {
+   p_ = p;
+   fun_ = fun;
+   arg1_ = arg1;
+  }
+  virtual ~ObjClosure1() {
+  }
+  virtual void Run() {
+    (p_->*fun_)(arg1_);
+  }
+ private:
+  Obj* p_;
+  Funct fun_;
+  Arg1 arg1_;
+}; 
+
+template <class Obj, class Funct, class Arg1, class Arg2> 
+class ObjClosure2: public ClosureInterface {
+ public:
+  ObjClosure2(Obj* p, Funct fun, Arg1 arg1, Arg2 arg2) {
+   p_ = p;
+   fun_ = fun;
+   arg1_ = arg1;
+   arg2_ = arg2;
+  }
+  virtual ~ObjClosure2() {
+  }
+  virtual void Run() {
+    (p_->*fun_)(arg1_, arg2_);
+  }
+ private:
+  Obj* p_;
+  Funct fun_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+}; 
+template <class Obj, class Funct, class Arg1, class Arg2, class Arg3> 
+class ObjClosure3: public ClosureInterface {
+ public:
+  ObjClosure3(Obj* p, Funct fun, Arg1 arg1, Arg2 arg2, Arg3 arg3) {
+   p_ = p;
+   fun_ = fun;
+   arg1_ = arg1;
+   arg2_ = arg2;
+   arg3_ = arg3;
+  }
+  virtual ~ObjClosure3() {
+  }
+  virtual void Run() {
+    (p_->*fun_)(arg1_, arg2_, arg3_);
+  }
+ private:
+  Obj* p_;
+  Funct fun_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+  Arg3 arg3_;
+}; 
+
+template<class R>
+ClosureInterface* NewClosure(R (*fun)()) {
+  return new Closure0<R (*)()>(fun);
+}
+
+template<class R, class Arg1>
+ClosureInterface* NewClosure(R (*fun)(Arg1), Arg1 arg1) {
+  return new Closure1<R (*)(Arg1), Arg1>(fun, arg1);
+}
+
+template<class R, class Arg1, class Arg2>
+ClosureInterface* NewClosure(R (*fun)(Arg1, Arg2), Arg1 arg1, Arg2 arg2) {
+  return new Closure2<R (*)(Arg1, Arg2), Arg1, Arg2>(fun, arg1, arg2);
+}
+
+template<class R, class Arg1, class Arg2, class Arg3>
+ClosureInterface* NewClosure(R (*fun)(Arg1, Arg2, Arg3), Arg1 arg1, Arg2 arg2, Arg3 arg3) {
+  return new Closure3<R (*)(Arg1, Arg2, Arg3), Arg1, Arg2, Arg3>(fun, arg1, arg2, arg3);
+}
+
+template<class R, class Obj>
+ClosureInterface* NewClosure(Obj* obj, R (Obj::* fun)()) {
+  return new ObjClosure0<Obj, R (Obj::* )()>(obj, fun);
+}
+
+template<class R, class Obj, class Arg1>
+ClosureInterface* NewClosure(Obj* obj, R (Obj::* fun)(Arg1), Arg1 arg1) {
+  return new ObjClosure1<Obj, R (Obj::* )(Arg1), Arg1>(obj, fun, arg1);
+}
+
+template<class R, class Obj, class Arg1, class Arg2>
+ClosureInterface* NewClosure(Obj* obj, R (Obj::* fun)(Arg1, Arg2), Arg1 arg1, Arg2 arg2) {
+  return new ObjClosure2<Obj, R (Obj::*)(Arg1, Arg2), Arg1, Arg2>(obj, fun, arg1, arg2);
+}
+
+template<class R, class Obj, class Arg1, class Arg2, class Arg3>
+ClosureInterface* NewClosure(Obj* obj, R (Obj::* fun)(Arg1, Arg2, Arg3), Arg1 arg1, Arg2 arg2, Arg3 arg3) {
+  return new ObjClosure3<Obj, R (Obj::*)(Arg1, Arg2, Arg3), Arg1, Arg2, Arg3>(obj, fun, arg1, arg2, arg3);
+}
+
+} // namespace limonp
+
+#endif // LIMONP_CLOSURE_HPP

package/cpp/cppjieba/deps/limonp/include/limonp/Colors.hpp

@@ -0,0 +1,31 @@
+#ifndef LIMONP_COLOR_PRINT_HPP
+#define LIMONP_COLOR_PRINT_HPP
+
+#include <string>
+#include <stdarg.h>
+
+namespace limonp {
+
+using std::string;
+
+enum Color {
+  BLACK = 30,
+  RED,
+  GREEN,
+  YELLOW,
+  BLUE,
+  PURPLE
+}; // enum Color
+
+static void ColorPrintln(enum Color color, const char * fmt, ...) {
+  va_list ap;
+  printf("\033[0;%dm", color);
+  va_start(ap, fmt);
+  vprintf(fmt, ap);
+  va_end(ap);
+  printf("\033[0m\n"); // if not \n , in some situation , the next lines will be set the same color unexpectedly
+}
+
+} // namespace limonp
+
+#endif // LIMONP_COLOR_PRINT_HPP

package/cpp/cppjieba/deps/limonp/include/limonp/Condition.hpp

@@ -0,0 +1,38 @@
+#ifndef LIMONP_CONDITION_HPP
+#define LIMONP_CONDITION_HPP
+
+#include "MutexLock.hpp"
+
+namespace limonp {
+
+class Condition : NonCopyable {
+ public:
+  explicit Condition(MutexLock& mutex)
+    : mutex_(mutex) {
+    XCHECK(!pthread_cond_init(&pcond_, NULL));
+  }
+
+  ~Condition() {
+    XCHECK(!pthread_cond_destroy(&pcond_));
+  }
+
+  void Wait() {
+    XCHECK(!pthread_cond_wait(&pcond_, mutex_.GetPthreadMutex()));
+  }
+
+  void Notify() {
+    XCHECK(!pthread_cond_signal(&pcond_));
+  }
+
+  void NotifyAll() {
+    XCHECK(!pthread_cond_broadcast(&pcond_));
+  }
+
+ private:
+  MutexLock& mutex_;
+  pthread_cond_t pcond_;
+}; // class Condition
+
+} // namespace limonp
+
+#endif // LIMONP_CONDITION_HPP