@luii/node-tesseract-ocr 2.0.13 → 2.3.2

package/dist/esm/index.mjs

@@ -13,6 +13,15 @@
  * or implied. See the License for the specific language governing
  * permissions and limitations under the License.
  */
+import { existsSync, createWriteStream } from "node:fs";
+import { mkdir, rename, rm, copyFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGunzip } from "node:zlib";
+import { lock } from "proper-lockfile";
+import { isValidTraineddata } from "./utils";
 /**
  * All available languages for tesseract
  * @readonly
@@ -227,33 +236,139 @@ export const LogLevels = {
     FATAL: "50000",
     OFF: "2147483647",
 };
-const fs = require("node:fs");
-const path = require("node:path");
+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 = path.join(os.homedir(), ".cache", "node-tesseract-ocr", "tessdata");
 const rootFromSource = path.resolve(__dirname, "../../");
 const bindingOptionsFromSource = path.resolve(rootFromSource, "binding-options.js");
-const bindingOptionsPath = fs.existsSync(bindingOptionsFromSource)
+const bindingOptionsPath = existsSync(bindingOptionsFromSource)
     ? bindingOptionsFromSource
     : path.resolve(process.cwd(), "binding-options.js");
-const prebuildRoot = fs.existsSync(bindingOptionsFromSource)
+const prebuildRoot = existsSync(bindingOptionsFromSource)
     ? rootFromSource
     : process.cwd();
 const { Tesseract: NativeTesseract } = require("pkg-prebuilds")(prebuildRoot, require(bindingOptionsPath));
 class Tesseract extends NativeTesseract {
+    document = {
+        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),
+    };
     constructor() {
         super();
     }
-    async init(options) {
-        // 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
+    async init(options = {}) {
+        options.langs ??= [];
+        options.ensureTraineddata ??= true;
+        options.cachePath ??= DEFAULT_CACHE_DIR;
+        options.dataPath ??= process.env.TESSDATA_PREFIX ?? options.cachePath;
+        options.progressCallback ??= undefined;
+        const cachePath = path.resolve(options.cachePath);
+        const dataPath = path.resolve(options.dataPath);
+        if (options.ensureTraineddata) {
+            for (const lang of [...options.langs, Language.osd]) {
+                const downloadBaseUrl = options.oem === OcrEngineModes.OEM_LSTM_ONLY
+                    ? TESSDATA4_BEST(lang)
+                    : TESSDATA4(lang);
+                lang &&
+                    (await this.ensureTrainingData({ lang, dataPath, cachePath, downloadBaseUrl }, options.progressCallback));
+            }
+        }
         return super.init(options);
     }
+    async ensureTrainingData({ lang, dataPath, cachePath, downloadBaseUrl }, progressCallback) {
+        const traineddataPath = path.join(dataPath, `${lang}.traineddata`);
+        const cacheTraineddataPath = path.join(cachePath, `${lang}.traineddata`);
+        if (await isValidTraineddata(cacheTraineddataPath)) {
+            if (traineddataPath !== cacheTraineddataPath) {
+                await mkdir(dataPath, { recursive: true });
+                await copyFile(cacheTraineddataPath, traineddataPath);
+            }
+            return traineddataPath;
+        }
+        if (await isValidTraineddata(traineddataPath)) {
+            return traineddataPath;
+        }
+        await mkdir(dataPath, { recursive: true });
+        const release = await lock(traineddataPath, {
+            lockfilePath: `${traineddataPath}.lock`,
+            stale: 10 * 60 * 1000,
+            update: 30 * 1000,
+            realpath: false,
+            retries: { retries: 50, minTimeout: 200, maxTimeout: 2000 },
+        });
+        try {
+            if (await isValidTraineddata(traineddataPath)) {
+                return traineddataPath;
+            }
+            if (traineddataPath !== cacheTraineddataPath &&
+                (await isValidTraineddata(cacheTraineddataPath))) {
+                await copyFile(cacheTraineddataPath, traineddataPath);
+                return traineddataPath;
+            }
+            const url = new URL(`${lang}.traineddata.gz`, downloadBaseUrl).toString();
+            const response = await fetch(url);
+            if (!response.ok || !response.body) {
+                throw new Error(`Failed to download traineddata for ${lang}: ${response.status} ${response.statusText}`);
+            }
+            const tmpPath = path.join(os.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 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 {
+                await pipeline(Readable.fromWeb(response.body), progressStream, createGunzip(), createWriteStream(tmpPath));
+                try {
+                    await rename(tmpPath, traineddataPath);
+                }
+                catch (error) {
+                    if (error.code === "EXDEV") {
+                        await copyFile(tmpPath, traineddataPath);
+                        await rm(tmpPath, { force: true });
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            catch (error) {
+                await rm(tmpPath, { force: true });
+                throw error;
+            }
+            return traineddataPath;
+        }
+        finally {
+            await release();
+        }
+    }
 }
 export { Tesseract, NativeTesseract };
 export default Tesseract;