react-native-jieba 0.3.0 → 0.4.1

package/Jieba.podspec

@@ -18,7 +18,21 @@ Pod::Spec.new do |s|
   s.exclude_files = "cpp/JiebaDictAndroid.{cpp,h}"
   s.private_header_files = "ios/**/*.h"
 
-  s.resources = ["cpp/cppjieba/dict/*.utf8"]
+  # The IDF dictionary (~5MB) is only read by `extract()` (TF-IDF keyword extraction). Apps that
+  # only tokenize can drop it from the bundle by setting RN_JIEBA_EXCLUDE_IDF_DICT=1 in the
+  # environment that evaluates the Podfile, e.g.
+  #
+  #   ENV["RN_JIEBA_EXCLUDE_IDF_DICT"] = "1"   # in the Podfile, before use_react_native!
+  #
+  # `extract()` then throws a descriptive error, exactly as it already does on web (jieba-wasm
+  # ships no IDF data). Every other API is unaffected.
+  exclude_idf_dict = ENV["RN_JIEBA_EXCLUDE_IDF_DICT"] == "1"
+  dict_files = Dir.glob(File.join(__dir__, "cpp/cppjieba/dict/*.utf8")).map do |path|
+    "cpp/cppjieba/dict/#{File.basename(path)}"
+  end
+  dict_files.reject! { |path| File.basename(path) == "idf.utf8" } if exclude_idf_dict
+
+  s.resources = dict_files
 
   s.pod_target_xcconfig = {
     "HEADER_SEARCH_PATHS" => [

package/README.md

@@ -3,7 +3,7 @@
 Native Chinese text segmentation for React Native, powered by [cppjieba](https://github.com/yanyiwu/cppjieba).
 
 - Runs on the New Architecture as a C++ Turbo Module — no bridge overhead, no JS port of jieba.
-- Ships the cppjieba dictionaries (`jieba.dict.utf8`, `hmm_model.utf8`, `idf.utf8`, `stop_words.utf8`, `user.dict.utf8`) inside the package, bundled as iOS pod resources and Android assets.
+- Ships the cppjieba dictionaries (`jieba.dict.utf8`, `hmm_model.utf8`, `idf.utf8`, `stop_words.utf8`, `user.dict.utf8`) inside the package, bundled as iOS pod resources and Android assets. The ~5.7 MB `idf.utf8` is loaded lazily and [can be excluded entirely](#reducing-app-size-excluding-the-idf-dictionary) in apps that never call `extract()`.
 - Supports the standard jieba modes: precise (`cut`), full (`cutAll`), search engine (`cutForSearch`), HMM (`cutHMM`), small-word (`cutSmall`), POS tagging (`tag`), and TF-IDF keyword extraction (`extract`).
 - Works on **web** (react-native-web) via [`jieba-wasm`](https://github.com/fengkx/jieba-wasm), with the same API.
 
@@ -105,7 +105,7 @@ On native, all segmentation calls are synchronous JSI calls — no Promises. On
 | `cutHMM(sentence)` | `(string) => string[]` | HMM-only segmentation. |
 | `cutSmall(sentence, maxWordLen)` | `(string, number) => string[]` | Limits the maximum word length. |
 | `tag(sentence)` | `(string) => Array<{ word, tag }>` | Part-of-speech tagging. |
-| `extract(sentence, topK?)` | `(string, number) => Array<{ word, weight }>` | TF-IDF keyword extraction. `topK` defaults to `5`. |
+| `extract(sentence, topK?)` | `(string, number) => Array<{ word, weight }>` | TF-IDF keyword extraction. `topK` defaults to `5`. Loads the IDF dictionary on first use; throws on web, and in native builds that [excluded it](#reducing-app-size-excluding-the-idf-dictionary). |
 | `insertUserWord(word, tag?)` | `(string, string) => boolean` | Adds a user dictionary word at runtime. |
 | `find(word)` | `(string) => boolean` | Tests whether a word is in the dictionary. |
 
@@ -186,9 +186,48 @@ To self-host the binary (CDN or custom path), pass `wasmUrl`:
 await prepareJieba({ wasmUrl: 'https://cdn.example.com/jieba_rs_wasm_bg.wasm' });
 ```
 
+## Reducing app size: excluding the IDF dictionary
+
+The bundled dictionaries account for most of this library's footprint, and `idf.utf8` is the
+largest single file at **~5.7 MB**. It is read by exactly one API — `extract()`, TF-IDF keyword
+extraction. Apps that only segment text (`cut`, `cutForSearch`, `tag`, …) never touch it.
+
+The extractor is built lazily on first use, so the dictionary costs nothing at startup either way.
+If your app never calls `extract()`, you can also drop the file from your binary entirely:
+
+**iOS** — set the environment variable before CocoaPods evaluates the podspec, e.g. at the top of
+your `Podfile`:
+
+```rb
+ENV['RN_JIEBA_EXCLUDE_IDF_DICT'] = '1'
+```
+
+Then reinstall pods (`bundle exec pod install`).
+
+**Android** — set a Gradle property in `android/gradle.properties`:
+
+```properties
+rnJiebaExcludeIdfDict=true
+```
+
+(or `ext.rnJiebaExcludeIdfDict = true` in `android/build.gradle`, or pass
+`-PrnJiebaExcludeIdfDict=true` on the command line).
+
+With the dictionary excluded, `extract()` throws a descriptive error and **every other API keeps
+working unchanged** — the same contract that already applies on web, where `extract()` is
+unsupported because jieba-wasm ships no IDF data. Guard it as you would for web:
+
+```ts
+const keywords = canExtract ? extract(sentence, 5) : [];
+```
+
+On Android this also skips copying the file out of the APK into `filesDir/jieba-dict/` on first
+run, saving the same ~5.7 MB of user device storage and shortening first-call extraction.
+
 ## How it works
 
-- The Turbo Module lives in `cpp/JiebaImpl.{h,cpp}` and wraps `cppjieba::Jieba` as a JSI Cxx module.
+- The Turbo Module lives in `cpp/JiebaImpl.{h,cpp}` and exposes the engine as a JSI Cxx module.
+- `cpp/JiebaEngine.{h,cpp}` composes cppjieba's primitives (one shared `DictTrie` + `HMMModel` across every segmenter) instead of using the `cppjieba::Jieba` facade. The facade holds a `KeywordExtractor` **by value**, so constructing it always loads `idf.utf8` and hard-fails when that file is absent; composing the pieces directly is what lets the extractor — and its dictionary — be built only if `extract()` is called.
 - iOS resolves the dictionary directory from `NSBundle` in `ios/OnLoad.mm` before the module is registered, so segmentation works immediately and `prepareJieba()` is a no-op on iOS.
 - Android ships the dictionary as AAR assets and extracts them to `filesDir/jieba-dict/`. This happens automatically: if `prepareJieba()` is never called, the C++ module extracts them synchronously on the first segmentation call via an fbjni call into `JiebaDict.extractDictDirFromNative` (a one-time cost). `prepareJieba()` does the same extraction asynchronously up front (through `JiebaAndroidHelperModule` → the codegen-exposed `setDictPath` JSI method) so that first call doesn't block.
 - `isJiebaReady()` is backed by the codegen-exposed `isReady()` JSI method, which reads the native engine state directly — so it stays correct even when the dictionary is resolved lazily on the first call.

package/android/CMakeLists.txt

@@ -6,6 +6,7 @@ set (CMAKE_VERBOSE_MAKEFILE ON)
 add_library(
     react-native-jieba    STATIC
     ../cpp/JiebaImpl.cpp
+    ../cpp/JiebaEngine.cpp
     ../cpp/JiebaDictAndroid.cpp
 )
 

package/android/build.gradle

@@ -2,6 +2,14 @@ buildscript {
   ext.safeExtGet = { prop, fallback ->
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
   }
+  // Resolves a flag from either `ext` (…/build.gradle: ext.rnJiebaExcludeIdfDict = true) or a
+  // Gradle property (gradle.properties: rnJiebaExcludeIdfDict=true / -PrnJiebaExcludeIdfDict=true),
+  // so consumers can set it whichever way their project already configures native modules.
+  ext.safeFlagGet = { prop, fallback ->
+    if (rootProject.ext.has(prop)) return rootProject.ext.get(prop).toString()
+    if (rootProject.hasProperty(prop)) return rootProject.property(prop).toString()
+    return fallback
+  }
   repositories {
     google()
     mavenCentral()
@@ -24,6 +32,11 @@ android {
   defaultConfig {
     minSdk safeExtGet('minSdkVersion', 24)
     targetSdk safeExtGet('targetSdkVersion', 35)
+    buildConfigField(
+      "boolean",
+      "RN_JIEBA_EXCLUDE_IDF_DICT",
+      safeFlagGet('rnJiebaExcludeIdfDict', 'false')
+    )
     externalNativeBuild {
       cmake {
         cppFlags "-std=c++20"
@@ -53,6 +66,25 @@ android {
       assets.srcDirs += "$projectDir/../cpp/cppjieba/dict"
     }
   }
+
+  // The IDF dictionary (~5MB) is only read by `extract()` (TF-IDF keyword extraction). Apps that
+  // only tokenize can drop it from the APK/AAB with:
+  //
+  //   rnJiebaExcludeIdfDict=true             # in android/gradle.properties, or
+  //   ext.rnJiebaExcludeIdfDict = true       # in android/build.gradle
+  //
+  // `extract()` then throws a descriptive error, exactly as it already does on web (jieba-wasm
+  // ships no IDF data). Every other API is unaffected. BuildConfig carries the same flag through to
+  // JiebaDict so the extractor does not try to copy a file that was never packaged.
+  buildFeatures {
+    buildConfig true
+  }
+
+  if (safeFlagGet('rnJiebaExcludeIdfDict', 'false') == 'true') {
+    androidResources {
+      ignoreAssetsPattern "idf.utf8"
+    }
+  }
 }
 
 dependencies {

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

@@ -21,13 +21,23 @@ import java.io.FileOutputStream
 object JiebaDict {
   const val DICT_DIR_NAME = "jieba-dict"
 
-  val DICT_FILES = arrayOf(
-    "jieba.dict.utf8",
-    "hmm_model.utf8",
-    "user.dict.utf8",
-    "idf.utf8",
-    "stop_words.utf8",
-  )
+  /** The IDF dictionary, needed only by `extract()` (TF-IDF keyword extraction). */
+  const val IDF_DICT_FILE = "idf.utf8"
+
+  /**
+   * Dictionary assets to extract.
+   *
+   * [IDF_DICT_FILE] is omitted when the library was built with `rnJiebaExcludeIdfDict=true`, since
+   * the asset is then not packaged at all and opening it would throw. `extract()` reports the
+   * omission with a descriptive error; every other API is unaffected.
+   */
+  val DICT_FILES: Array<String> = buildList {
+    add("jieba.dict.utf8")
+    add("hmm_model.utf8")
+    add("user.dict.utf8")
+    if (!BuildConfig.RN_JIEBA_EXCLUDE_IDF_DICT) add(IDF_DICT_FILE)
+    add("stop_words.utf8")
+  }.toTypedArray()
 
   /**
    * Application context captured at module construction so the native (C++)

package/cpp/JiebaEngine.cpp

@@ -0,0 +1,18 @@
+#include "JiebaEngine.h"
+
+#include <fstream>
+
+namespace rnjieba {
+
+bool JiebaEngine::UnicodeFileExists(const std::string& path) {
+  if (path.empty()) {
+    return false;
+  }
+  // Probe by opening rather than stat()-ing: cppjieba itself loads the dictionary through
+  // an ifstream, so this reports exactly the condition that would otherwise trip its
+  // XCHECK — including a path that exists but cannot be read.
+  std::ifstream ifs(path.c_str());
+  return ifs.is_open();
+}
+
+}

package/cpp/JiebaEngine.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include <cppjieba/DictTrie.hpp>
+#include <cppjieba/FullSegment.hpp>
+#include <cppjieba/HMMModel.hpp>
+#include <cppjieba/HMMSegment.hpp>
+#include <cppjieba/KeywordExtractor.hpp>
+#include <cppjieba/MPSegment.hpp>
+#include <cppjieba/MixSegment.hpp>
+#include <cppjieba/QuerySegment.hpp>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace rnjieba {
+
+/**
+ * A cppjieba engine whose keyword extractor is built ON DEMAND.
+ *
+ * `cppjieba::Jieba` holds `KeywordExtractor` by value, so its constructor always
+ * loads `idf.utf8` and hard-fails (XCHECK) when that file is absent. That makes the
+ * ~5MB IDF dictionary a mandatory dependency of plain segmentation, even though only
+ * `extract()` ever reads it.
+ *
+ * This type composes the same cppjieba primitives directly, sharing one `DictTrie` and
+ * one `HMMModel` across every segmenter exactly as `cppjieba::Jieba` does, but defers the
+ * `KeywordExtractor` until `extract()` is first called. Apps that only tokenize therefore
+ * never load the IDF dictionary — and may omit the file from their bundle entirely (see
+ * `excludeIdfDict` in the README).
+ */
+class JiebaEngine {
+public:
+  JiebaEngine(
+    std::string dictPath,
+    std::string hmmModelPath,
+    std::string userDictPath,
+    std::string idfPath,
+    std::string stopWordPath
+  )
+    : idfPath_(std::move(idfPath)),
+      stopWordPath_(std::move(stopWordPath)),
+      dictTrie_(dictPath, userDictPath),
+      model_(hmmModelPath),
+      mpSeg_(&dictTrie_),
+      hmmSeg_(&model_),
+      mixSeg_(&dictTrie_, &model_),
+      fullSeg_(&dictTrie_),
+      querySeg_(&dictTrie_, &model_) {}
+
+  void Cut(const std::string& sentence, std::vector<std::string>& words, bool hmm) const {
+    mixSeg_.Cut(sentence, words, hmm);
+  }
+  void CutAll(const std::string& sentence, std::vector<std::string>& words) const {
+    fullSeg_.Cut(sentence, words);
+  }
+  void CutForSearch(const std::string& sentence, std::vector<std::string>& words, bool hmm) const {
+    querySeg_.Cut(sentence, words, hmm);
+  }
+  void CutHMM(const std::string& sentence, std::vector<std::string>& words) const {
+    hmmSeg_.Cut(sentence, words);
+  }
+  void CutSmall(
+    const std::string& sentence,
+    std::vector<std::string>& words,
+    size_t maxWordLen
+  ) const {
+    mpSeg_.Cut(sentence, words, maxWordLen);
+  }
+  void Tag(
+    const std::string& sentence,
+    std::vector<std::pair<std::string, std::string>>& words
+  ) const {
+    mixSeg_.Tag(sentence, words);
+  }
+  bool InsertUserWord(const std::string& word, const std::string& tag) {
+    return dictTrie_.InsertUserWord(word, tag);
+  }
+  bool Find(const std::string& word) {
+    return dictTrie_.Find(word);
+  }
+
+  /**
+   * The TF-IDF keyword extractor, constructed on first use.
+   *
+   * Reuses this engine's already-loaded trie and HMM model, so the only additional cost is
+   * reading `idf.utf8` and `stop_words.utf8`. Throws `std::runtime_error` when the IDF
+   * dictionary is missing — mirroring the web backend, where `extract()` is likewise
+   * unsupported because jieba-wasm ships no IDF data.
+   */
+  const cppjieba::KeywordExtractor& Extractor() {
+    if (!extractor_) {
+      if (!UnicodeFileExists(idfPath_)) {
+        throw std::runtime_error(
+          "react-native-jieba: extract() is unavailable because the IDF dictionary was not "
+          "found at '" + idfPath_ + "'. This build excluded it (see the `excludeIdfDict` "
+          "build flag). Re-enable the IDF dictionary to use extract(); cut()/tag() are "
+          "unaffected."
+        );
+      }
+      extractor_ = std::make_unique<cppjieba::KeywordExtractor>(
+        &dictTrie_, &model_, idfPath_, stopWordPath_
+      );
+    }
+    return *extractor_;
+  }
+
+private:
+  static bool UnicodeFileExists(const std::string& path);
+
+  std::string idfPath_;
+  std::string stopWordPath_;
+
+  cppjieba::DictTrie dictTrie_;
+  cppjieba::HMMModel model_;
+
+  // All share the trie and model above.
+  cppjieba::MPSegment mpSeg_;
+  cppjieba::HMMSegment hmmSeg_;
+  cppjieba::MixSegment mixSeg_;
+  cppjieba::FullSegment fullSeg_;
+  cppjieba::QuerySegment querySeg_;
+
+  std::unique_ptr<cppjieba::KeywordExtractor> extractor_;
+};
+
+}

package/cpp/JiebaImpl.cpp

@@ -4,7 +4,7 @@
 #include "JiebaDictAndroid.h"
 #endif
 
-#include <cppjieba/Jieba.hpp>
+#include "JiebaEngine.h"
 
 #include <memory>
 #include <mutex>
@@ -27,8 +27,8 @@ std::string& dictPathStorage() {
   return p;
 }
 
-std::unique_ptr<cppjieba::Jieba>& jiebaStorage() {
-  static std::unique_ptr<cppjieba::Jieba> j;
+std::unique_ptr<rnjieba::JiebaEngine>& jiebaStorage() {
+  static std::unique_ptr<rnjieba::JiebaEngine> j;
   return j;
 }
 
@@ -74,7 +74,7 @@ void JiebaImpl::setDictPath(jsi::Runtime& rt, jsi::String path) {
   setDictPathFromNative(path.utf8(rt));
 }
 
-cppjieba::Jieba& JiebaImpl::getJieba() {
+rnjieba::JiebaEngine& JiebaImpl::getJieba() {
   std::lock_guard<std::mutex> lock(dictMutex());
   if (!jiebaStorage()) {
 #ifdef __ANDROID__
@@ -95,7 +95,9 @@ cppjieba::Jieba& JiebaImpl::getJieba() {
         "The native module failed to locate bundled dict files."
       );
     }
-    jiebaStorage() = std::make_unique<cppjieba::Jieba>(
+    // The IDF path is recorded but NOT read here: JiebaEngine loads it only if extract() is
+    // called, so a build that omits idf.utf8 still tokenizes normally.
+    jiebaStorage() = std::make_unique<rnjieba::JiebaEngine>(
       joinPath(base, "jieba.dict.utf8"),
       joinPath(base, "hmm_model.utf8"),
       joinPath(base, "user.dict.utf8"),
@@ -153,7 +155,7 @@ jsi::Array JiebaImpl::tag(jsi::Runtime& rt, jsi::String sentence) {
 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);
+  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);

package/cpp/JiebaImpl.h

@@ -6,8 +6,8 @@
 #include <mutex>
 #include <string>
 
-namespace cppjieba {
-class Jieba;
+namespace rnjieba {
+class JiebaEngine;
 }
 
 namespace facebook::react {
@@ -32,7 +32,7 @@ public:
   bool find(jsi::Runtime& rt, jsi::String word);
 
 private:
-  cppjieba::Jieba& getJieba();
+  rnjieba::JiebaEngine& getJieba();
 };
 
 }

package/lib/module/jieba.js

@@ -19,6 +19,18 @@ export function cutSmall(sentence, maxWordLen) {
 export function tag(sentence) {
   return Jieba.tag(sentence);
 }
+
+/**
+ * TF-IDF keyword extraction.
+ *
+ * Requires the IDF dictionary, which is loaded lazily on the first call (every other API works
+ * without it). Throws when that dictionary is unavailable:
+ *  - on **web**, always — jieba-wasm ships no IDF data;
+ *  - on **native**, only in builds that opted out of bundling it via `RN_JIEBA_EXCLUDE_IDF_DICT=1`
+ *    (iOS) or `rnJiebaExcludeIdfDict=true` (Android), which drops ~5MB from the app.
+ *
+ * Guard it in cross-platform code, or in any app that may be built with the dictionary excluded.
+ */
 export function extract(sentence, topK = 5) {
   return Jieba.extract(sentence, topK);
 }

package/lib/module/jieba.js.map

@@ -1 +1 @@
-{"version":3,"names":["Jieba","cut","sentence","hmm","cutAll","cutForSearch","cutHMM","cutSmall","maxWordLen","tag","extract","topK","insertUserWord","word","find"],"sourceRoot":"../../src","sources":["jieba.ts"],"mappings":";;AAAA,OAAOA,KAAK,MAAM,eAAe;AAKjC,OAAO,SAASC,GAAGA,CAACC,QAAgB,EAAEC,GAAY,GAAG,IAAI,EAAY;EACnE,OAAOH,KAAK,CAACC,GAAG,CAACC,QAAQ,EAAEC,GAAG,CAAC;AACjC;AAEA,OAAO,SAASC,MAAMA,CAACF,QAAgB,EAAY;EACjD,OAAOF,KAAK,CAACI,MAAM,CAACF,QAAQ,CAAC;AAC/B;AAEA,OAAO,SAASG,YAAYA,CAACH,QAAgB,EAAEC,GAAY,GAAG,IAAI,EAAY;EAC5E,OAAOH,KAAK,CAACK,YAAY,CAACH,QAAQ,EAAEC,GAAG,CAAC;AAC1C;AAEA,OAAO,SAASG,MAAMA,CAACJ,QAAgB,EAAY;EACjD,OAAOF,KAAK,CAACM,MAAM,CAACJ,QAAQ,CAAC;AAC/B;AAEA,OAAO,SAASK,QAAQA,CAACL,QAAgB,EAAEM,UAAkB,EAAY;EACvE,OAAOR,KAAK,CAACO,QAAQ,CAACL,QAAQ,EAAEM,UAAU,CAAC;AAC7C;AAEA,OAAO,SAASC,GAAGA,CAACP,QAAgB,EAAY;EAC9C,OAAOF,KAAK,CAACS,GAAG,CAACP,QAAQ,CAAC;AAC5B;AAEA,OAAO,SAASQ,OAAOA,CAACR,QAAgB,EAAES,IAAY,GAAG,CAAC,EAAa;EACrE,OAAOX,KAAK,CAACU,OAAO,CAACR,QAAQ,EAAES,IAAI,CAAC;AACtC;AAEA,OAAO,SAASC,cAAcA,CAACC,IAAY,EAAEJ,GAAW,GAAG,EAAE,EAAW;EACtE,OAAOT,KAAK,CAACY,cAAc,CAACC,IAAI,EAAEJ,GAAG,CAAC;AACxC;AAEA,OAAO,SAASK,IAAIA,CAACD,IAAY,EAAW;EAC1C,OAAOb,KAAK,CAACc,IAAI,CAACD,IAAI,CAAC;AACzB","ignoreList":[]}
+{"version":3,"names":["Jieba","cut","sentence","hmm","cutAll","cutForSearch","cutHMM","cutSmall","maxWordLen","tag","extract","topK","insertUserWord","word","find"],"sourceRoot":"../../src","sources":["jieba.ts"],"mappings":";;AAAA,OAAOA,KAAK,MAAM,eAAe;AAKjC,OAAO,SAASC,GAAGA,CAACC,QAAgB,EAAEC,GAAY,GAAG,IAAI,EAAY;EACnE,OAAOH,KAAK,CAACC,GAAG,CAACC,QAAQ,EAAEC,GAAG,CAAC;AACjC;AAEA,OAAO,SAASC,MAAMA,CAACF,QAAgB,EAAY;EACjD,OAAOF,KAAK,CAACI,MAAM,CAACF,QAAQ,CAAC;AAC/B;AAEA,OAAO,SAASG,YAAYA,CAACH,QAAgB,EAAEC,GAAY,GAAG,IAAI,EAAY;EAC5E,OAAOH,KAAK,CAACK,YAAY,CAACH,QAAQ,EAAEC,GAAG,CAAC;AAC1C;AAEA,OAAO,SAASG,MAAMA,CAACJ,QAAgB,EAAY;EACjD,OAAOF,KAAK,CAACM,MAAM,CAACJ,QAAQ,CAAC;AAC/B;AAEA,OAAO,SAASK,QAAQA,CAACL,QAAgB,EAAEM,UAAkB,EAAY;EACvE,OAAOR,KAAK,CAACO,QAAQ,CAACL,QAAQ,EAAEM,UAAU,CAAC;AAC7C;AAEA,OAAO,SAASC,GAAGA,CAACP,QAAgB,EAAY;EAC9C,OAAOF,KAAK,CAACS,GAAG,CAACP,QAAQ,CAAC;AAC5B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASQ,OAAOA,CAACR,QAAgB,EAAES,IAAY,GAAG,CAAC,EAAa;EACrE,OAAOX,KAAK,CAACU,OAAO,CAACR,QAAQ,EAAES,IAAI,CAAC;AACtC;AAEA,OAAO,SAASC,cAAcA,CAACC,IAAY,EAAEJ,GAAW,GAAG,EAAE,EAAW;EACtE,OAAOT,KAAK,CAACY,cAAc,CAACC,IAAI,EAAEJ,GAAG,CAAC;AACxC;AAEA,OAAO,SAASK,IAAIA,CAACD,IAAY,EAAW;EAC1C,OAAOb,KAAK,CAACc,IAAI,CAACD,IAAI,CAAC;AACzB","ignoreList":[]}

package/lib/typescript/src/jieba.d.ts

@@ -12,6 +12,17 @@ export declare function cutForSearch(sentence: string, hmm?: boolean): string[];
 export declare function cutHMM(sentence: string): string[];
 export declare function cutSmall(sentence: string, maxWordLen: number): string[];
 export declare function tag(sentence: string): Tagged[];
+/**
+ * TF-IDF keyword extraction.
+ *
+ * Requires the IDF dictionary, which is loaded lazily on the first call (every other API works
+ * without it). Throws when that dictionary is unavailable:
+ *  - on **web**, always — jieba-wasm ships no IDF data;
+ *  - on **native**, only in builds that opted out of bundling it via `RN_JIEBA_EXCLUDE_IDF_DICT=1`
+ *    (iOS) or `rnJiebaExcludeIdfDict=true` (Android), which drops ~5MB from the app.
+ *
+ * Guard it in cross-platform code, or in any app that may be built with the dictionary excluded.
+ */
 export declare function extract(sentence: string, topK?: number): Keyword[];
 export declare function insertUserWord(word: string, tag?: string): boolean;
 export declare function find(word: string): boolean;

package/lib/typescript/src/jieba.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jieba.d.ts","sourceRoot":"","sources":["../../../src/jieba.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AACnD,MAAM,MAAM,OAAO,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,wBAAgB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAE,OAAc,GAAG,MAAM,EAAE,CAEnE;AAED,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAEjD;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAE,OAAc,GAAG,MAAM,EAAE,CAE5E;AAED,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAEjD;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAEvE;AAED,wBAAgB,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAE9C;AAED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,MAAU,GAAG,OAAO,EAAE,CAErE;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAAW,GAAG,OAAO,CAEtE;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1C"}
+{"version":3,"file":"jieba.d.ts","sourceRoot":"","sources":["../../../src/jieba.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AACnD,MAAM,MAAM,OAAO,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,wBAAgB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAE,OAAc,GAAG,MAAM,EAAE,CAEnE;AAED,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAEjD;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAE,OAAc,GAAG,MAAM,EAAE,CAE5E;AAED,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAEjD;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAEvE;AAED,wBAAgB,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAE9C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,MAAU,GAAG,OAAO,EAAE,CAErE;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAAW,GAAG,OAAO,CAEtE;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-jieba",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Native Chinese text segmentation for React Native, powered by cppjieba.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -26,6 +26,8 @@
     "ios/generated",
     "cpp/JiebaImpl.h",
     "cpp/JiebaImpl.cpp",
+    "cpp/JiebaEngine.h",
+    "cpp/JiebaEngine.cpp",
     "cpp/JiebaDictAndroid.h",
     "cpp/JiebaDictAndroid.cpp",
     "cpp/cppjieba/LICENSE",
@@ -53,7 +55,8 @@
     "test": "jest",
     "release": "release-it --only-version",
     "web": "vite",
-    "build:web": "vite build"
+    "build:web": "vite build",
+    "prepack": "node ./scripts/verify-pack-contents.mjs"
   },
   "keywords": [
     "react-native",

package/src/jieba.ts

@@ -27,6 +27,17 @@ export function tag(sentence: string): Tagged[] {
   return Jieba.tag(sentence);
 }
 
+/**
+ * TF-IDF keyword extraction.
+ *
+ * Requires the IDF dictionary, which is loaded lazily on the first call (every other API works
+ * without it). Throws when that dictionary is unavailable:
+ *  - on **web**, always — jieba-wasm ships no IDF data;
+ *  - on **native**, only in builds that opted out of bundling it via `RN_JIEBA_EXCLUDE_IDF_DICT=1`
+ *    (iOS) or `rnJiebaExcludeIdfDict=true` (Android), which drops ~5MB from the app.
+ *
+ * Guard it in cross-platform code, or in any app that may be built with the dictionary excluded.
+ */
 export function extract(sentence: string, topK: number = 5): Keyword[] {
   return Jieba.extract(sentence, topK);
 }