@ohos-ports/nodejieba 0.0.0-stage → 3.5.8-beta.0

package/binding.gyp

@@ -0,0 +1,63 @@
+{
+  "targets": [
+    {
+      "target_name": "nodejieba",
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "xcode_settings": {
+        "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+        "CLANG_CXX_LIBRARY": "libc++",
+        "MACOSX_DEPLOYMENT_TARGET": "10.13",
+      },
+      "msvs_settings": {
+        "VCCLCompilerTool": {
+          "ExceptionHandling": 1,
+          "AdditionalOptions": ["/std:c++14","/utf-8"]
+        },
+      },
+      "win_delay_load_hook": "true",
+      "sources": [
+        "./lib/index.cpp",
+        "./lib/nodejieba.cpp",
+      ],
+      "cflags": [
+        "-DLOGGING_LEVEL=LL_WARNING"
+      ],
+      "include_dirs" : [
+        "<!(node -p \"require('node-addon-api').include_dir\")",
+        "./submodules/cppjieba/include",
+        "./submodules/cppjieba/deps/limonp/include",
+      ],
+      'configurations': {
+        'Release': {
+          'msvs_settings': {
+            'VCCLCompilerTool': {
+              'ExceptionHandling': '1',
+              'PreprocessorDefinitions': ['LOGGING_LEVEL=LL_WARNING'],
+            }
+          }
+        }
+      },
+      "conditions": [
+        [ "OS == 'mac'", {
+          "xcode_settings": {
+            "OTHER_CPLUSPLUSFLAGS":[
+              "-mmacosx-version-min=10.13",
+              "-std=c++14",
+              "-stdlib=libc++",
+              "-DLOGGING_LEVEL=LL_WARNING",
+            ]
+          }
+        }],
+        # 添加Windows特定条件
+        [ "OS == 'win'", {
+          "msvs_settings": {
+            "VCCLCompilerTool": {
+              "AdditionalOptions": ["/std:c++14"]
+            }
+          }
+        }]
+      ],
+    }
+  ]
+}

package/index.js

@@ -0,0 +1,77 @@
+var path = require('path');
+var BINARY_PATH = path.join(__dirname, 'build/Release/nodejieba.node');
+var nodejieba;
+var bindingLoadError;
+
+function getNodejieba() {
+  if (nodejieba) {
+    return nodejieba;
+  }
+  if (bindingLoadError) {
+    throw bindingLoadError;
+  }
+  try {
+    nodejieba = require(BINARY_PATH);
+    return nodejieba;
+  } catch (err) {
+    if (err && err.code === 'MODULE_NOT_FOUND') {
+      bindingLoadError = new Error(
+        "nodejieba native binding was not found at " + BINARY_PATH + ". " +
+        "This usually means install scripts were skipped or the native binary failed to download/build. " +
+        "Try reinstalling without --ignore-scripts or run `npm rebuild nodejieba`."
+      );
+      bindingLoadError.code = 'BINDING_NOT_FOUND';
+      bindingLoadError.cause = err;
+      throw bindingLoadError;
+    }
+    throw err;
+  }
+}
+
+var isDictLoaded = false;
+
+var DICT_DIR = __dirname + "/submodules/cppjieba/dict/";
+
+var exports = {
+  DEFAULT_DICT: DICT_DIR + "jieba.dict.utf8",
+  DEFAULT_HMM_DICT: DICT_DIR + "hmm_model.utf8",
+  DEFAULT_USER_DICT: DICT_DIR + "user.dict.utf8",
+  DEFAULT_IDF_DICT: DICT_DIR + "idf.utf8",
+  DEFAULT_STOP_WORD_DICT: DICT_DIR + "stop_words.utf8",
+
+  load: function (dictJson) {
+    if (!dictJson) {
+      dictJson = {};
+    }
+    dict         = dictJson.dict       || exports.DEFAULT_DICT;
+    hmmDict      = dictJson.hmmDict    || exports.DEFAULT_HMM_DICT;
+    userDict     = dictJson.userDict   || exports.DEFAULT_USER_DICT;
+    idfDict      = dictJson.idfDict    || exports.DEFAULT_IDF_DICT;
+    stopWordDict = dictJson.stopWordDict || exports.DEFAULT_STOP_WORD_DICT;
+
+    var result = getNodejieba().load(dict, hmmDict, userDict, idfDict, stopWordDict);
+    isDictLoaded = true;
+    return result;
+  }
+};
+
+function wrapWithDictLoad(functName) {
+  exports[functName] = function () {
+    if (!isDictLoaded) {
+      exports.load();
+    }
+    return getNodejieba()[functName].apply(this, arguments);
+  }
+}
+
+wrapWithDictLoad("cut");
+wrapWithDictLoad("cutAll");
+wrapWithDictLoad("cutHMM");
+wrapWithDictLoad("cutForSearch");
+wrapWithDictLoad("cutSmall");
+wrapWithDictLoad("tag");
+wrapWithDictLoad("extract");
+wrapWithDictLoad("textRankExtract");
+wrapWithDictLoad("insertWord");
+
+module.exports = exports;

package/lib/index.cpp

@@ -0,0 +1,3 @@
+#include "nodejieba.h"
+
+NODE_API_ADDON(NodeJieba)

package/lib/nodejieba.cpp

@@ -0,0 +1,218 @@
+#include "nodejieba.h"
+
+#include "utils.h"
+
+#include "cppjieba/Jieba.hpp"
+#include "cppjieba/KeywordExtractor.hpp"
+#include "cppjieba/TextRankExtractor.hpp"
+
+NodeJieba::NodeJieba(Napi::Env env, Napi::Object exports) {
+  DefineAddon(exports, {
+    InstanceMethod("load", &NodeJieba::load),
+    InstanceMethod("cut", &NodeJieba::cut),
+    InstanceMethod("cutAll", &NodeJieba::cutAll),
+    InstanceMethod("cutHMM", &NodeJieba::cutHMM),
+    InstanceMethod("cutForSearch", &NodeJieba::cutForSearch),
+    InstanceMethod("cutSmall", &NodeJieba::cutSmall),
+    InstanceMethod("tag", &NodeJieba::tag),
+    InstanceMethod("extract", &NodeJieba::extract),
+    InstanceMethod("textRankExtract", &NodeJieba::textRankExtract),
+    InstanceMethod("insertWord", &NodeJieba::insertWord)
+  });
+}
+
+Napi::Value NodeJieba::load(const Napi::CallbackInfo& info) {
+  if (info.Length() != 5) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+
+  std::string dictPath = info[0].As<Napi::String>();
+  std::string modelPath = info[1].As<Napi::String>();
+  std::string userDictPath = info[2].As<Napi::String>();
+  std::string idfPath = info[3].As<Napi::String>();
+  std::string stopWordsPath = info[4].As<Napi::String>();
+
+  delete _jieba_handle;
+  _jieba_handle = new cppjieba::Jieba(dictPath,
+                                  modelPath,
+                                  userDictPath,
+                                  idfPath,
+                                  stopWordsPath);
+
+  delete _text_rank_extractor_handle;
+  _text_rank_extractor_handle = new cppjieba
+		      ::TextRankExtractor(dictPath,
+                                  modelPath,
+                                  stopWordsPath,
+                                  userDictPath);
+
+  return Napi::Boolean::New(info.Env(), true);
+}
+
+Napi::Value NodeJieba::insertWord(const Napi::CallbackInfo& info) {
+  if(info.Length() < 1) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+  std::string word = info[0].As<Napi::String>();
+  std::string tag = "x";
+  if(info.Length() > 1) {
+      tag = info[1].As<Napi::String>();
+  }
+
+  if( !_jieba_handle ){
+    Napi::Error::New(info.Env(), "Before calling any other function you have to call load() first").ThrowAsJavaScriptException();
+  }
+
+  if(!_jieba_handle->InsertUserWord(word, tag)) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+
+  return Napi::Boolean::New(info.Env(), true);
+}
+
+Napi::Value NodeJieba::cut(const Napi::CallbackInfo& info) {
+  if (info.Length() == 0) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+  std::string sentence = info[0].As<Napi::String>();
+  bool useHMM = false;
+  if (info.Length() > 1) {
+    useHMM = info[1].As<Napi::Boolean>();
+  }
+
+  if( !_jieba_handle ){
+    Napi::Error::New(info.Env(), "Before calling any other function you have to call load() first").ThrowAsJavaScriptException();
+  }
+
+  std::vector<std::string> words;
+  _jieba_handle->Cut(sentence, words, useHMM);
+  Napi::Array outArray;
+  WrapVector(info.Env(), words, outArray);
+  return outArray;
+}
+
+Napi::Value NodeJieba::cutHMM(const Napi::CallbackInfo& info) {
+  if (info.Length() == 0) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+  std::string sentence = info[0].As<Napi::String>();
+
+  if( !_jieba_handle ){
+    Napi::Error::New(info.Env(), "Before calling any other function you have to call load() first").ThrowAsJavaScriptException();
+  }
+
+  std::vector<std::string> words;
+  _jieba_handle->CutHMM(sentence, words);
+  Napi::Array outArray;
+  WrapVector(info.Env(), words, outArray);
+  return outArray;
+}
+
+Napi::Value NodeJieba::cutAll(const Napi::CallbackInfo& info) {
+  if (info.Length() == 0) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+  std::string sentence = info[0].As<Napi::String>();
+
+  if( !_jieba_handle ){
+    Napi::Error::New(info.Env(), "Before calling any other function you have to call load() first").ThrowAsJavaScriptException();
+  }
+
+  std::vector<std::string> words;
+  _jieba_handle->CutAll(sentence, words);
+  Napi::Array outArray;
+  WrapVector(info.Env(), words, outArray);
+  return outArray;
+}
+
+Napi::Value NodeJieba::cutForSearch(const Napi::CallbackInfo& info) {
+  if (info.Length() == 0) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+  std::string sentence = info[0].As<Napi::String>();
+  bool useHMM = false;
+  if (info.Length() > 1) {
+    useHMM = info[1].As<Napi::Boolean>();
+  }
+
+  if( !_jieba_handle ){
+    Napi::Error::New(info.Env(), "Before calling any other function you have to call load() first").ThrowAsJavaScriptException();
+  }
+
+  std::vector<std::string> words;
+  _jieba_handle->CutForSearch(sentence, words, useHMM);
+  Napi::Array outArray;
+  WrapVector(info.Env(), words, outArray);
+  return outArray;
+}
+
+Napi::Value NodeJieba::cutSmall(const Napi::CallbackInfo& info) {
+  if (info.Length() < 2) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+  std::string sentence = info[0].As<Napi::String>();
+  size_t word_len_limit = info[1].As<Napi::Number>().Int32Value();
+
+  if( !_jieba_handle ){
+    Napi::Error::New(info.Env(), "Before calling any other function you have to call load() first").ThrowAsJavaScriptException();
+  }
+
+  std::vector<std::string> words;
+  _jieba_handle->CutSmall(sentence, words, word_len_limit);
+  Napi::Array outArray;
+  WrapVector(info.Env(), words, outArray);
+  return outArray;
+}
+
+Napi::Value NodeJieba::tag(const Napi::CallbackInfo& info) {
+  if (info.Length() == 0) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+  std::string sentence = info[0].As<Napi::String>();
+
+  if( !_jieba_handle ){
+    Napi::Error::New(info.Env(), "Before calling any other function you have to call load() first").ThrowAsJavaScriptException();
+  }
+
+  std::vector<std::pair<std::string, std::string> > words;
+  _jieba_handle->Tag(sentence, words);
+  Napi::Array outArray;
+  WrapPairVector(info.Env(), words, outArray);
+  return outArray;
+}
+
+Napi::Value NodeJieba::extract(const Napi::CallbackInfo& info) {
+  if (info.Length() != 2) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+  std::string sentence = info[0].As<Napi::String>();
+  size_t topN = info[1].As<Napi::Number>().Int32Value();
+
+  if( !_jieba_handle ){
+    Napi::Error::New(info.Env(), "Before calling any other function you have to call load() first").ThrowAsJavaScriptException();
+  }
+
+  std::vector<std::pair<std::string, double> > words;
+  _jieba_handle->extractor.Extract(sentence, words, topN);
+  Napi::Array outArray;
+  WrapPairVector(info.Env(), words, outArray);
+  return outArray;
+}
+
+Napi::Value NodeJieba::textRankExtract(const Napi::CallbackInfo& info) {
+  if (info.Length() != 2) {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+  std::string sentence = info[0].As<Napi::String>();
+  size_t topN = info[1].As<Napi::Number>().Int32Value();
+
+  if( !_text_rank_extractor_handle ){
+    Napi::Error::New(info.Env(), "Before calling any other function you have to call load() first").ThrowAsJavaScriptException();
+  }
+
+  std::vector<std::pair<std::string, double> > words;
+  _text_rank_extractor_handle->Extract(sentence, words, topN);
+  Napi::Array outArray;
+  WrapPairVector(info.Env(), words, outArray);
+  return outArray;
+}

package/lib/nodejieba.h

@@ -0,0 +1,28 @@
+#ifndef NODEJIBEA_SRC_NODEJIEBA_H
+#define NODEJIBEA_SRC_NODEJIEBA_H
+
+#include <napi.h>
+
+namespace cppjieba{ class Jieba; class TextRankExtractor; }
+
+class NodeJieba : public Napi::Addon<NodeJieba> {
+public:
+  NodeJieba(Napi::Env env, Napi::Object exports);
+
+private:
+  Napi::Value load(const Napi::CallbackInfo& info);
+  Napi::Value cut(const Napi::CallbackInfo& info);
+  Napi::Value cutAll(const Napi::CallbackInfo& info);
+  Napi::Value cutHMM(const Napi::CallbackInfo& info);
+  Napi::Value cutForSearch(const Napi::CallbackInfo& info);
+  Napi::Value cutSmall(const Napi::CallbackInfo& info);
+  Napi::Value tag(const Napi::CallbackInfo& info);
+  Napi::Value extract(const Napi::CallbackInfo& info);
+  Napi::Value textRankExtract(const Napi::CallbackInfo& info);
+  Napi::Value insertWord(const Napi::CallbackInfo& info);
+
+  cppjieba::Jieba* _jieba_handle{nullptr};
+  cppjieba::TextRankExtractor* _text_rank_extractor_handle{nullptr};
+};
+
+#endif // NODEJIBEA_SRC_NODEJIEBA_H

package/lib/utils.h

@@ -0,0 +1,47 @@
+#ifndef NODEJIEBA_SRC_UTLS_H
+#define NODEJIEBA_SRC_UTLS_H
+
+#include <string>
+#include <utility>
+#include <vector>
+
+inline void WrapVector(Napi::Env env, std::vector<std::string> &ov, Napi::Array &array) {
+  array = Napi::Array::New(env, ov.size());
+  for(size_t i = 0; i < ov.size(); i++) {
+      array.Set(i, Napi::String::New(env, ov[i]));
+  }
+}
+
+inline void WrapPairVector(Napi::Env env, std::vector<std::pair<std::string,double> > &ov, Napi::Array &array) {
+  array = Napi::Array::New(env, ov.size());
+  for(size_t i = 0; i < ov.size(); i++) {
+    Napi::Object obj = Napi::Object::New(env);
+    Napi::Value k;
+    Napi::Value v;
+    k = Napi::String::New(env, "word");
+    v = Napi::String::New(env, ov[i].first);
+    obj.Set(k, v);
+    k = Napi::String::New(env, "weight");
+    v = Napi::Number::New(env, ov[i].second);
+    obj.Set(k, v);
+    array.Set(i, obj);
+  }
+}
+
+inline void WrapPairVector(Napi::Env env, std::vector<std::pair<std::string,std::string> > &ov, Napi::Array &array) {
+  array = Napi::Array::New(env, ov.size());
+  for(size_t i = 0; i < ov.size(); i++) {
+    Napi::Object obj = Napi::Object::New(env);
+    Napi::Value k;
+    Napi::Value v;
+    k = Napi::String::New(env, "word");
+    v = Napi::String::New(env, ov[i].first);
+    obj.Set(k, v);
+    k = Napi::String::New(env, "tag");
+    v = Napi::String::New(env, ov[i].second);
+    obj.Set(k, v);
+    array.Set(i, obj);
+  }
+}
+
+#endif

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@ohos-ports/nodejieba",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "chinese word segmentation for node",
+  "version": "3.5.8-beta.0",
+  "author": "Yanyi Wu <wuyanyi09@foxmail.com>",
+  "maintainers": [
+    "Yanyi Wu <wuyanyi09@foxmail.com>"
+  ],
+  "main": "./index.js",
+  "typings": "types/index.d.ts",
+  "engines": {
+    "node": ">= 14.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/nodejieba/3.5.8"
+  },
+  "keywords": [
+    "chinese",
+    "segment",
+    "cppjieba",
+    "jieba",
+    "中文分词",
+    "结巴分词"
+  ],
+  "dependencies": {
+    "@mapbox/node-pre-gyp": "^1.0.10",
+    "node-addon-api": "^5.1.0"
+  },
+  "devDependencies": {
+    "mocha": "~10.7.3",
+    "should": "~13.2.3",
+    "typescript": "^5.0.4"
+  },
+  "scripts": {
+    "test": "mocha --timeout 10s -R spec test/test.js && mocha --timeout 10s -R spec test/load_dict_test.js && mocha --timeout 10s -R spec test/missing_binding_test.js",
+    "install": "npx @mapbox/node-pre-gyp install --fallback-to-build",
+    "rebuild": "npx @mapbox/node-pre-gyp rebuild"
+  },
+  "binary": {
+    "module_name": "nodejieba",
+    "module_path": "./build/Release/",
+    "host": "https://github.com/yanyiwu/nodejieba/releases/download/",
+    "remote_path": "v{version}",
+    "package_name": "{module_name}-v{version}-{node_abi}-{platform}-{arch}-{libc}.tar.gz"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "files": [
+    "index.js",
+    "lib/",
+    "types/",
+    "binding.gyp",
+    "submodules/cppjieba/dict/",
+    "submodules/cppjieba/include/",
+    "submodules/cppjieba/deps/limonp/include/",
+    "build/Release/*.node",
+    "CHANGELOG.md",
+    "test/"
+  ]
+}