@juspay/neurolink 9.1.1 → 9.3.0

package/dist/processors/document/OpenDocumentProcessor.js

@@ -0,0 +1,210 @@
+/**
+ * OpenDocument Processor
+ *
+ * Processes OpenDocument format files (.odt, .ods, .odp) by extracting
+ * text content from the internal XML structure.
+ *
+ * @module processors/document/OpenDocumentProcessor
+ */
+import { createRequire } from "node:module";
+import { BaseFileProcessor } from "../base/BaseFileProcessor.js";
+import { SIZE_LIMITS } from "../config/index.js";
+const require = createRequire(import.meta.url);
+/**
+ * OpenDocument Processor - handles .odt, .ods, .odp files
+ *
+ * OpenDocument files are ZIP archives containing XML content.
+ * The main content is in content.xml within the archive.
+ *
+ * Priority: ~105 (between Word and Text)
+ */
+export class OpenDocumentProcessor extends BaseFileProcessor {
+    constructor() {
+        super({
+            maxSizeMB: SIZE_LIMITS.DOCUMENT_MAX_MB,
+            timeoutMs: 60000,
+            supportedMimeTypes: [
+                "application/vnd.oasis.opendocument.text",
+                "application/vnd.oasis.opendocument.spreadsheet",
+                "application/vnd.oasis.opendocument.presentation",
+            ],
+            supportedExtensions: [".odt", ".ods", ".odp"],
+            fileTypeName: "OpenDocument",
+            defaultFilename: "document.odt",
+        });
+    }
+    /**
+     * Validate that the file is a valid ZIP archive (OpenDocument format)
+     */
+    async validateDownloadedFile(buffer, _fileInfo) {
+        if (buffer.length < 4) {
+            return "File too small to be a valid OpenDocument file";
+        }
+        // Check for PK (ZIP) signature
+        const signature = buffer.subarray(0, 2).toString("ascii");
+        if (signature !== "PK") {
+            return "Invalid OpenDocument format - not a valid ZIP archive";
+        }
+        return null;
+    }
+    /**
+     * Build the processed result by extracting content from the OpenDocument
+     */
+    buildProcessedResult(buffer, fileInfo) {
+        const ext = this.getExtension(fileInfo.name);
+        const format = this.detectFormat(ext);
+        let textContent = "";
+        let paragraphCount = 0;
+        let truncated = false;
+        try {
+            // Dynamically import adm-zip to avoid issues if not available
+            const AdmZip = require("adm-zip");
+            const zip = new AdmZip(buffer);
+            // Try to get content.xml
+            const contentEntry = zip.getEntry("content.xml");
+            if (contentEntry) {
+                const xmlContent = contentEntry.getData().toString("utf-8");
+                const extracted = this.extractTextFromXml(xmlContent);
+                textContent = extracted.text;
+                paragraphCount = extracted.paragraphCount;
+                // Check for truncation
+                const maxChars = 500000; // ~500KB of text
+                if (textContent.length > maxChars) {
+                    textContent =
+                        textContent.substring(0, maxChars) + "\n\n... [Content truncated]";
+                    truncated = true;
+                }
+            }
+            else {
+                throw new Error("content.xml not found in OpenDocument archive");
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            throw new Error(`Failed to extract OpenDocument content: ${message}`);
+        }
+        return {
+            textContent,
+            format,
+            paragraphCount,
+            truncated,
+            buffer,
+            mimetype: fileInfo.mimetype || "application/vnd.oasis.opendocument.text",
+            size: fileInfo.size,
+            filename: this.getFilename(fileInfo),
+        };
+    }
+    /**
+     * Decode HTML entities in a single pass to prevent double-unescaping.
+     * Sequential replacement is vulnerable: "&amp;lt;" → "&lt;" → "<"
+     * Single-pass avoids this by replacing each entity exactly once.
+     */
+    decodeHtmlEntities(text) {
+        const entityMap = {
+            "&amp;": "&",
+            "&lt;": "<",
+            "&gt;": ">",
+            "&quot;": '"',
+            "&apos;": "'",
+        };
+        return text.replace(/&(?:amp|lt|gt|quot|apos);/g, (match) => entityMap[match] ?? match);
+    }
+    /**
+     * Extract text content from OpenDocument XML
+     */
+    extractTextFromXml(xml) {
+        const paragraphs = [];
+        // Extract text from <text:p> elements (paragraphs)
+        // Also handle <text:h> (headings) and <text:span> (spans)
+        const textPattern = /<text:(?:p|h|span)[^>]*>([\s\S]*?)<\/text:(?:p|h|span)>/gi;
+        const matches = xml.matchAll(textPattern);
+        for (const match of matches) {
+            // Remove nested tags iteratively to handle fragments like "<scr<script>ipt>"
+            let stripped = match[1];
+            let prev;
+            do {
+                prev = stripped;
+                stripped = stripped.replace(/<[^>]+>/g, "");
+            } while (stripped !== prev);
+            const text = this.decodeHtmlEntities(stripped).trim();
+            if (text) {
+                paragraphs.push(text);
+            }
+        }
+        // Also try a simpler approach for spreadsheets and presentations
+        // where content might be in different structures
+        if (paragraphs.length === 0) {
+            // Try to extract any text content between tags (iterative to handle nested fragments)
+            let stripped = xml;
+            let prev;
+            do {
+                prev = stripped;
+                stripped = stripped.replace(/<[^>]+>/g, " ");
+            } while (stripped !== prev);
+            const simpleText = this.decodeHtmlEntities(stripped.replace(/\s+/g, " ")).trim();
+            if (simpleText) {
+                paragraphs.push(simpleText);
+            }
+        }
+        return {
+            text: paragraphs.join("\n\n"),
+            paragraphCount: paragraphs.length,
+        };
+    }
+    /**
+     * Detect the OpenDocument format from file extension
+     */
+    detectFormat(ext) {
+        switch (ext?.toLowerCase()) {
+            case ".odt":
+                return "odt";
+            case ".ods":
+                return "ods";
+            case ".odp":
+                return "odp";
+            default:
+                return "unknown";
+        }
+    }
+    /**
+     * Get file extension from filename
+     */
+    getExtension(filename) {
+        const match = filename.toLowerCase().match(/\.[^.]+$/);
+        return match ? match[0] : null;
+    }
+}
+// =============================================================================
+// SINGLETON INSTANCE
+// =============================================================================
+/**
+ * Singleton instance of OpenDocumentProcessor
+ */
+export const openDocumentProcessor = new OpenDocumentProcessor();
+// =============================================================================
+// HELPER FUNCTIONS
+// =============================================================================
+/**
+ * Check if a file is an OpenDocument file by MIME type or extension
+ */
+export function isOpenDocumentFile(mimetype, filename) {
+    return openDocumentProcessor.isFileSupported(mimetype, filename);
+}
+/**
+ * Validate OpenDocument file size against limits
+ */
+export function validateOpenDocumentSize(sizeBytes) {
+    return sizeBytes <= SIZE_LIMITS.DOCUMENT_MAX_MB * 1024 * 1024;
+}
+/**
+ * Process an OpenDocument file
+ */
+export async function processOpenDocument(fileInfo, options) {
+    return openDocumentProcessor.processFile(fileInfo, options);
+}
+/**
+ * Get the maximum allowed OpenDocument file size in MB
+ */
+export function getOpenDocumentMaxSizeMB() {
+    return SIZE_LIMITS.DOCUMENT_MAX_MB;
+}

package/dist/processors/document/RtfProcessor.d.ts

@@ -0,0 +1,152 @@
+/**
+ * RTF Document Processor
+ *
+ * Processes Rich Text Format (.rtf) files by extracting plain text content
+ * from RTF control codes. Uses a lightweight text extraction approach
+ * without requiring external dependencies.
+ *
+ * Key features:
+ * - RTF control code stripping
+ * - Text content extraction
+ * - Raw content preservation for debugging
+ * - No external dependencies required
+ *
+ * Priority: ~110 (document format, processed after binary formats)
+ *
+ * @module processors/document/RtfProcessor
+ *
+ * @example
+ * ```typescript
+ * import { rtfProcessor, processRtf, isRtfFile } from "./document/index.js";
+ *
+ * // Check if a file is an RTF file
+ * if (isRtfFile("application/rtf", "document.rtf")) {
+ *   const result = await processRtf({
+ *     id: "file-123",
+ *     name: "document.rtf",
+ *     mimetype: "application/rtf",
+ *     size: 10240,
+ *     buffer: rtfBuffer,
+ *   });
+ *
+ *   if (result.success) {
+ *     console.log(`Text content: ${result.data.textContent}`);
+ *   }
+ * }
+ * ```
+ */
+import { BaseFileProcessor } from "../base/BaseFileProcessor.js";
+import type { FileInfo, FileProcessingResult, ProcessOptions } from "../base/types.js";
+export type { ProcessedRtf } from "../base/types.js";
+import type { ProcessedRtf } from "../base/types.js";
+/**
+ * RTF Processor - handles Rich Text Format files.
+ *
+ * Extracts plain text from RTF documents by stripping RTF control codes.
+ * This is a lightweight implementation that doesn't require external
+ * RTF parsing libraries.
+ *
+ * Priority: ~110 (document format)
+ *
+ * @example
+ * ```typescript
+ * const processor = new RtfProcessor();
+ *
+ * const result = await processor.processFile({
+ *   id: "file-123",
+ *   name: "report.rtf",
+ *   mimetype: "application/rtf",
+ *   size: 5120,
+ *   buffer: rtfBuffer,
+ * });
+ *
+ * if (result.success) {
+ *   console.log("Extracted text:", result.data.textContent);
+ * }
+ * ```
+ */
+export declare class RtfProcessor extends BaseFileProcessor<ProcessedRtf> {
+    constructor();
+    /**
+     * Validate downloaded RTF document.
+     * Checks for RTF header signature "{\\rtf".
+     *
+     * @param buffer - Downloaded file content
+     * @param fileInfo - Original file information
+     * @returns null if valid, error message if invalid
+     */
+    protected validateDownloadedFile(buffer: Buffer, _fileInfo: FileInfo): Promise<string | null>;
+    /**
+     * Build the processed RTF result.
+     * Extracts plain text by stripping RTF control codes.
+     *
+     * @param buffer - Raw file content
+     * @param fileInfo - Original file information
+     * @returns Processed RTF with extracted text content
+     */
+    protected buildProcessedResult(buffer: Buffer, fileInfo: FileInfo): ProcessedRtf;
+    /**
+     * Extract plain text from RTF content.
+     * Strips RTF control codes, groups, and formatting commands.
+     *
+     * This is a basic RTF parser that handles common RTF constructs:
+     * - Control groups like {\fonttbl...}
+     * - Control words like \par, \b, \i
+     * - Special characters like \' hex escapes
+     * - Newlines from \par and \line commands
+     *
+     * @param rtf - Raw RTF content
+     * @returns Extracted plain text
+     */
+    private extractText;
+}
+/**
+ * Singleton instance of the RtfProcessor.
+ * Use this for all RTF document processing to share configuration.
+ */
+export declare const rtfProcessor: RtfProcessor;
+/**
+ * Check if a file is an RTF document.
+ *
+ * @param mimetype - MIME type of the file
+ * @param filename - Filename for detection
+ * @returns true if the file is a supported RTF document
+ *
+ * @example
+ * ```typescript
+ * if (isRtfFile("application/rtf", "document.rtf")) {
+ *   console.log("This is an RTF document");
+ * }
+ * ```
+ */
+export declare function isRtfFile(mimetype: string, filename: string): boolean;
+/**
+ * Validate RTF document size against configured limit.
+ *
+ * @param sizeBytes - File size in bytes
+ * @returns true if size is within the allowed limit
+ */
+export declare function validateRtfSize(sizeBytes: number): boolean;
+/**
+ * Process an RTF document.
+ *
+ * @param fileInfo - File information (can include URL or buffer)
+ * @param options - Optional processing options
+ * @returns Processing result with success flag and either data or error
+ *
+ * @example
+ * ```typescript
+ * const result = await processRtf({
+ *   id: "file-123",
+ *   name: "report.rtf",
+ *   mimetype: "application/rtf",
+ *   size: 10240,
+ *   buffer: rtfBuffer,
+ * });
+ *
+ * if (result.success) {
+ *   console.log("Extracted text:", result.data.textContent);
+ * }
+ * ```
+ */
+export declare function processRtf(fileInfo: FileInfo, options?: ProcessOptions): Promise<FileProcessingResult<ProcessedRtf>>;