import type { OCRProcessorProvider, Processor, ProcessorInput, ProcessorResult } from '../types.js';
import { createTesseractJsOCRProvider } from '../providers/tesseract-ocr.js';
import type { OCRConfig } from '../types.js';
const SUPPORTED_MIME_TYPES = [
'image/png',
'image/jpeg',
'image/webp',
'image/gif',
'image/tiff',
'image/bmp',
];
function resolveProvider(provider?: OCRProcessorProvider): OCRProcessorProvider {
return provider ?? createTesseractJsOCRProvider();
}
function generateHOCR(text: string, fileName: string): string {
const lines = text.split('\n').filter((line) => line.trim().length > 0);
const wordBlocks = lines
.map((line, idx) => {
return ` ${escapeHtml(line)}`;
})
.join('\n');
return `
${escapeHtml(fileName)} - OCR Output
${wordBlocks}
`;
}
function escapeHtml(text: string): string {
return text
.replace(/&/g, '&')
.replace(//g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
}
export function createOCRProcessor(config: OCRConfig = {}): Processor {
const { language = 'eng', outputFormat = 'text', provider } = config;
return {
name: 'ocr',
supportedMimeTypes: SUPPORTED_MIME_TYPES,
async process(input: ProcessorInput, getData: () => Promise): Promise {
if (!SUPPORTED_MIME_TYPES.includes(input.mimeType)) {
return {
success: false,
artifacts: [],
error: `Unsupported MIME type: ${input.mimeType}`,
};
}
try {
const imageData = await getData();
const artifacts = [];
const baseKey = input.storageKey.replace(/\.[^/.]+$/, '');
const runtime = resolveProvider(provider);
const needsHOCR = outputFormat === 'hocr' || outputFormat === 'all';
const extracted = await runtime.recognize({
input,
imageData,
language,
includeHOCR: needsHOCR,
});
const extractedAt = new Date().toISOString();
if (outputFormat === 'text' || outputFormat === 'all') {
const textData = new TextEncoder().encode(extracted.text);
artifacts.push({
kind: 'ocr-text',
data: textData,
mimeType: 'text/plain',
storageKey: `${baseKey}-ocr.txt`,
metadata: {
language,
format: 'text',
sourceFileId: input.fileId,
sourceVersionId: input.versionId,
originalSize: imageData.length,
textLength: extracted.text.length,
confidence: extracted.confidence,
extractedAt,
},
});
}
if (outputFormat === 'json' || outputFormat === 'all') {
const jsonData = JSON.stringify(
{
text: extracted.text,
language,
confidence: extracted.confidence,
extractedAt,
},
null,
2,
);
const jsonBytes = new TextEncoder().encode(jsonData);
artifacts.push({
kind: 'ocr-json',
data: jsonBytes,
mimeType: 'application/json',
storageKey: `${baseKey}-ocr.json`,
metadata: {
language,
format: 'json',
sourceFileId: input.fileId,
sourceVersionId: input.versionId,
textLength: extracted.text.length,
confidence: extracted.confidence,
},
});
}
if (outputFormat === 'hocr' || outputFormat === 'all') {
const hocrData = extracted.hocr && extracted.hocr.trim().length > 0
? extracted.hocr
: generateHOCR(extracted.text, input.fileName);
const hocrBytes = new TextEncoder().encode(hocrData);
artifacts.push({
kind: 'ocr-hocr',
data: hocrBytes,
mimeType: 'text/html',
storageKey: `${baseKey}-ocr.hocr`,
metadata: {
language,
format: 'hocr',
sourceFileId: input.fileId,
sourceVersionId: input.versionId,
confidence: extracted.confidence,
},
});
}
return {
success: true,
artifacts,
};
} catch (error) {
return {
success: false,
artifacts: [],
error: error instanceof Error ? error.message : 'Unknown OCR error',
};
}
},
};
}
export { SUPPORTED_MIME_TYPES as OCR_SUPPORTED_MIME_TYPES };