node:internal/event_target:1011
  process.nextTick(() => { throw err; });
                           ^
Error: Cannot find module '**/[path]/**directus/extensions/worker-script/node/index.js'
    at Function.Module._resolveFilename (node:internal/modules/cjs/loader:1028:15)
    at Function.Module._load (node:internal/modules/cjs/loader:873:27)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)
    at MessagePort.<anonymous> (node:internal/main/worker_thread:197:24)
    at MessagePort.[nodejs.internal.kHybridDispatch] (node:internal/event_target:736:20)
    at MessagePort.exports.emitMessage (node:internal/per_context/messageport:23:28)
Emitted 'error' event on Worker instance at:
    at Worker.[kOnErrorMessage] (node:internal/worker:298:10)
    at Worker.[kOnMessage] (node:internal/worker:309:37)
    at MessagePort.<anonymous> (node:internal/worker:205:57)
    at MessagePort.[nodejs.internal.kHybridDispatch] (node:internal/event_target:736:20)
    at MessagePort.exports.emitMessage (node:internal/per_context/messageport:23:28) {
  code: 'MODULE_NOT_FOUND',
  requireStack: []
}
error Command failed with exit code 1.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.

import {
    createWorker,
    ImageLike,
    InitOptions,
    Lang,
    OEM,
    OutputFormats,
    RecognizeOptions,
    Worker,
} from "tesseract.js";

/**
 * A service for performing OCR (Optical Character Recognition) on images. This
 * service uses tesseract.js to recognize text from images in various languages.
 */
class OCRService {
    private worker?: Worker;

    /**
     * Asynchronously initializes the OCR worker with the specified configuration.
     * This setup includes language loading, OCR Engine Mode (OEM), and other initialization options.
     * @param {Partial<WorkerOptions>} options - Optional configuration for Tesseract's worker, including paths,
     *                                              logging, and error handling settings.
     * @param {string | Lang[]} languages - Language codes or language objects to be loaded by Tesseract. This can be a single language code as a string, or an array of language codes or Lang objects for multilingual support.
     * @param {OEM} oem - OCR Engine Mode to use. This parameter defines the type of engine(s) Tesseract uses during recognition. It can significantly affect the accuracy and speed of OCR.
     * @param {string | Partial<InitOptions>} config - Additional configuration for initializing the Tesseract worker. This can be a string representing a pre-defined configuration, or an object providing detailed control over the OCR process.
     */
    public async init(
        langs?: string | Lang[],
        options?: Partial<WorkerOptions>,
        oem?: OEM,
        config?: string | Partial<InitOptions>
    ): Promise<void> {
        try {
            const worker = await createWorker("eng", 1, {
                logger: m => console.log(m),
            });

            await worker.load();
            this.worker = worker;
        } catch (error) {
            console.error("Failed to initialize OCR worker:", error);
            throw new Error("OCR initialization failed");
        }
    }

    /**
     * Performs OCR on a given image using Tesseract.js. This method supports various image inputs
     * and allows for detailed customization of the OCR process through optional parameters.
     * @param {ImageLike} image - The image to be processed. Can be a path or URL as a string,
     *                             or any other supported ImageLike type (e.g., HTMLImageElement, Blob).
     * @param {Partial<RecognizeOptions>} [options] - Optional. Custom options for OCR processing,
     *                                                including region of interest (rectangle), rotation, and PDF output settings.
     * @param {Partial<OutputFormats>} [output] - Optional. Specifies the desired output formats
     *                                            (e.g., text, hocr, pdf). If not provided, defaults to text output.
     * @returns {Promise<string>} The recognized text from the image, or other requested format based on output parameter.
     * @throws {Error} When text recognition fails or if the worker is not initialized.
     */
    public async recognizeText(
        image: ImageLike,
        options?: Partial<RecognizeOptions>,
        output?: Partial<OutputFormats>
    ): Promise<string> {
        try {
            if (!this.worker) {
                throw new Error("OCR worker is not initialized");
            }

            // Adjust options based on parameters
            const recognizeOptions: Partial<RecognizeOptions> = { ...options };
            const outputFormats: Partial<OutputFormats> = {
                text: true,
                ...output,
            };

            // Perform OCR. The output format will depend on the 'output' parameter.
            const result = await this.worker.recognize(
                image,
                recognizeOptions,
                outputFormats
            );

            return result.data.text;
        } catch (error) {
            console.error("Failed to recognize text from image:", error);
            throw new Error("Text recognition failed");
        }
    }

    /**
     * Terminates the OCR worker, freeing up resources.
     */
    public async terminate(): Promise<void> {
        try {
            if (!this.worker) {
                return;
            }

            await this.worker.terminate();
            this.worker = undefined;
        } catch (error) {
            console.error("Failed to terminate OCR worker:", error);
            throw new Error("OCR termination failed");
        }
    }
}