@luii/node-tesseract-ocr 2.0.13 → 2.3.2

package/binding-options.js

@@ -0,0 +1,4 @@
+module.exports = {
+  name: "node-tesseract-ocr",
+  napi_versions: [10],
+};

package/dist/cjs/index.cjs

@@ -23,8 +23,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NativeTesseract = exports.Tesseract = exports.LogLevels = exports.PageSegmentationModes = exports.OcrEngineModes = exports.Language = void 0;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_stream_1 = require("node:stream");
+const promises_2 = require("node:stream/promises");
+const node_zlib_1 = require("node:zlib");
+const proper_lockfile_1 = require("proper-lockfile");
+const utils_1 = require("./utils");
 /**
  * All available languages for tesseract
  * @readonly
@@ -239,14 +251,15 @@ exports.LogLevels = {
     FATAL: "50000",
     OFF: "2147483647",
 };
-const fs = require("node:fs");
-const path = require("node:path");
-const rootFromSource = path.resolve(__dirname, "../../");
-const bindingOptionsFromSource = path.resolve(rootFromSource, "binding-options.js");
-const bindingOptionsPath = fs.existsSync(bindingOptionsFromSource)
+const TESSDATA4_BEST = (lang) => `https://cdn.jsdelivr.net/npm/@tesseract.js-data/${lang}/4.0.0_best_int/`;
+const TESSDATA4 = (lang) => `https://cdn.jsdelivr.net/npm/@tesseract.js-data/${lang}/4.0.0/`;
+const DEFAULT_CACHE_DIR = node_path_1.default.join(node_os_1.default.homedir(), ".cache", "node-tesseract-ocr", "tessdata");
+const rootFromSource = node_path_1.default.resolve(__dirname, "../../");
+const bindingOptionsFromSource = node_path_1.default.resolve(rootFromSource, "binding-options.js");
+const bindingOptionsPath = (0, node_fs_1.existsSync)(bindingOptionsFromSource)
     ? bindingOptionsFromSource
-    : path.resolve(process.cwd(), "binding-options.js");
-const prebuildRoot = fs.existsSync(bindingOptionsFromSource)
+    : node_path_1.default.resolve(process.cwd(), "binding-options.js");
+const prebuildRoot = (0, node_fs_1.existsSync)(bindingOptionsFromSource)
     ? rootFromSource
     : process.cwd();
 const { Tesseract: NativeTesseract } = require("pkg-prebuilds")(prebuildRoot, require(bindingOptionsPath));
@@ -254,24 +267,137 @@ exports.NativeTesseract = NativeTesseract;
 class Tesseract extends NativeTesseract {
     constructor() {
         super();
+        Object.defineProperty(this, "document", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                begin: this.beginProcessPages.bind(this),
+                addPage: this.addProcessPage.bind(this),
+                finish: this.finishProcessPages.bind(this),
+                abort: this.abortProcessPages.bind(this),
+                status: this.getProcessPagesStatus.bind(this),
+            }
+        });
     }
-    init(options) {
+    init() {
         const _super = Object.create(null, {
             init: { get: () => super.init }
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            // scan train data for any files
-            // check whether the requested langs are available/cached
-            // if not
-            //   fetch traineddata from cdn
-            //     - add .lock file to downloaded file (while downloading, so other instances
-            //       can wait on it and dont have to download again)
-            //     - place into tesseract standard folder
-            //  if available
-            //    just go on with the init function of the native addon
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            var _a, _b, _c, _d, _e, _f;
+            (_a = options.langs) !== null && _a !== void 0 ? _a : (options.langs = []);
+            (_b = options.ensureTraineddata) !== null && _b !== void 0 ? _b : (options.ensureTraineddata = true);
+            (_c = options.cachePath) !== null && _c !== void 0 ? _c : (options.cachePath = DEFAULT_CACHE_DIR);
+            (_d = options.dataPath) !== null && _d !== void 0 ? _d : (options.dataPath = (_e = process.env.TESSDATA_PREFIX) !== null && _e !== void 0 ? _e : options.cachePath);
+            (_f = options.progressCallback) !== null && _f !== void 0 ? _f : (options.progressCallback = undefined);
+            const cachePath = node_path_1.default.resolve(options.cachePath);
+            const dataPath = node_path_1.default.resolve(options.dataPath);
+            if (options.ensureTraineddata) {
+                for (const lang of [...options.langs, exports.Language.osd]) {
+                    const downloadBaseUrl = options.oem === exports.OcrEngineModes.OEM_LSTM_ONLY
+                        ? TESSDATA4_BEST(lang)
+                        : TESSDATA4(lang);
+                    lang &&
+                        (yield this.ensureTrainingData({ lang, dataPath, cachePath, downloadBaseUrl }, options.progressCallback));
+                }
+            }
             return _super.init.call(this, options);
         });
     }
+    ensureTrainingData(_a, progressCallback_1) {
+        return __awaiter(this, arguments, void 0, function* ({ lang, dataPath, cachePath, downloadBaseUrl }, progressCallback) {
+            const traineddataPath = node_path_1.default.join(dataPath, `${lang}.traineddata`);
+            const cacheTraineddataPath = node_path_1.default.join(cachePath, `${lang}.traineddata`);
+            if (yield (0, utils_1.isValidTraineddata)(cacheTraineddataPath)) {
+                if (traineddataPath !== cacheTraineddataPath) {
+                    yield (0, promises_1.mkdir)(dataPath, { recursive: true });
+                    yield (0, promises_1.copyFile)(cacheTraineddataPath, traineddataPath);
+                }
+                return traineddataPath;
+            }
+            if (yield (0, utils_1.isValidTraineddata)(traineddataPath)) {
+                return traineddataPath;
+            }
+            yield (0, promises_1.mkdir)(dataPath, { recursive: true });
+            const release = yield (0, proper_lockfile_1.lock)(traineddataPath, {
+                lockfilePath: `${traineddataPath}.lock`,
+                stale: 10 * 60 * 1000,
+                update: 30 * 1000,
+                realpath: false,
+                retries: { retries: 50, minTimeout: 200, maxTimeout: 2000 },
+            });
+            try {
+                if (yield (0, utils_1.isValidTraineddata)(traineddataPath)) {
+                    return traineddataPath;
+                }
+                if (traineddataPath !== cacheTraineddataPath &&
+                    (yield (0, utils_1.isValidTraineddata)(cacheTraineddataPath))) {
+                    yield (0, promises_1.copyFile)(cacheTraineddataPath, traineddataPath);
+                    return traineddataPath;
+                }
+                const url = new URL(`${lang}.traineddata.gz`, downloadBaseUrl).toString();
+                const response = yield fetch(url);
+                if (!response.ok || !response.body) {
+                    throw new Error(`Failed to download traineddata for ${lang}: ${response.status} ${response.statusText}`);
+                }
+                const tmpPath = node_path_1.default.join(node_os_1.default.tmpdir(), [
+                    "node-tesseract-ocr",
+                    lang,
+                    "traineddata",
+                    process.pid,
+                    Date.now(),
+                    Math.random().toString(36).slice(2),
+                ].join("-"));
+                const totalBytesHeader = response.headers.get("content-length");
+                const totalBytes = totalBytesHeader
+                    ? Number(totalBytesHeader)
+                    : undefined;
+                let downloadedBytes = 0;
+                const progressStream = new node_stream_1.Transform({
+                    transform(chunk, _, callback) {
+                        if (progressCallback) {
+                            downloadedBytes += chunk.length;
+                            const percent = typeof totalBytes === "number" && Number.isFinite(totalBytes)
+                                ? (downloadedBytes / totalBytes) * 100
+                                : undefined;
+                            progressCallback({
+                                lang,
+                                url,
+                                downloadedBytes,
+                                totalBytes: Number.isFinite(totalBytes) ? totalBytes : undefined,
+                                percent,
+                            });
+                        }
+                        callback(null, chunk);
+                    },
+                });
+                try {
+                    yield (0, promises_2.pipeline)(node_stream_1.Readable.fromWeb(response.body), progressStream, (0, node_zlib_1.createGunzip)(), (0, node_fs_1.createWriteStream)(tmpPath));
+                    try {
+                        yield (0, promises_1.rename)(tmpPath, traineddataPath);
+                    }
+                    catch (error) {
+                        if (error.code === "EXDEV") {
+                            yield (0, promises_1.copyFile)(tmpPath, traineddataPath);
+                            yield (0, promises_1.rm)(tmpPath, { force: true });
+                        }
+                        else {
+                            throw error;
+                        }
+                    }
+                }
+                catch (error) {
+                    yield (0, promises_1.rm)(tmpPath, { force: true });
+                    throw error;
+                }
+                return traineddataPath;
+            }
+            finally {
+                yield release();
+            }
+        });
+    }
 }
 exports.Tesseract = Tesseract;
 exports.default = Tesseract;