openrxiv-cli 0.0.2

package/dist/utils/meca-processor.js

@@ -0,0 +1,503 @@
+import fs from 'fs';
+import path from 'path';
+import { fromXml } from 'xast-util-from-xml';
+import axios from 'axios';
+import AdmZip from 'adm-zip';
+import { characterEntities } from 'character-entities';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/**
+ * Process a MECA file and extract metadata
+ * @param mecaPath Path to the MECA file (local file path)
+ * @param options Processing options
+ * @returns ProcessMecaResult with success status and extracted paper data
+ */
+export async function processMecaFile(mecaPath, options) {
+    try {
+        console.log(`🔍 Processing MECA file: ${mecaPath}`);
+        // Create output directory if specified
+        if (options.output && !fs.existsSync(options.output)) {
+            fs.mkdirSync(options.output, { recursive: true });
+        }
+        // Extract MECA file (auto-select method based on file size and options)
+        const extractedDir = await extractMecaAuto(mecaPath, options.output, options.selective);
+        console.log(`📂 Extracted to: ${extractedDir}`);
+        // Parse manifest
+        const manifest = await parseManifest(extractedDir);
+        console.log(`📋 Found ${manifest.item.length} items`);
+        // Find JATS XML file
+        const jatsFile = findJATSFile(manifest, extractedDir);
+        if (!jatsFile) {
+            throw new Error('No JATS XML file found in manifest');
+        }
+        console.log(`📄 JATS file found: ${jatsFile}`);
+        // Parse JATS XML using unified ecosystem
+        console.log(`🔍 Starting JATS parsing...`);
+        let jatsData;
+        try {
+            jatsData = await parseJATS(jatsFile);
+            console.log(`🔍 JATS parsed - DOI: ${jatsData.doi}, Version: ${jatsData.version}, Received Date: ${jatsData.receivedDate}`);
+        }
+        catch (jatsError) {
+            console.error('❌ Error parsing JATS:', jatsError);
+            throw jatsError;
+        }
+        // Prepare paper data
+        const paperData = {
+            doi: jatsData.doi,
+            version: jatsData.articleVersion,
+            receivedDate: new Date(jatsData.receivedDate).toISOString(),
+            acceptedDate: jatsData.acceptedDate
+                ? new Date(jatsData.acceptedDate).toISOString()
+                : undefined,
+            batch: options.batch,
+            server: options.server,
+            s3Key: options.s3Key,
+            fileSize: fs.statSync(mecaPath).size,
+            title: jatsData.title,
+        };
+        // Post to API
+        const apiResponse = await postToAPI(paperData, options.apiUrl, options.apiKey);
+        console.log('✅ Paper added to database');
+        return {
+            success: true,
+            paper: apiResponse,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+async function extractMecaAuto(mecaPath, outputDir = './downloads', selective = true) {
+    // Check file size to determine extraction method
+    const stats = fs.statSync(mecaPath);
+    const fileSizeGB = stats.size / (1024 * 1024 * 1024);
+    const LARGE_FILE_THRESHOLD_GB = 1.9;
+    if (fileSizeGB > LARGE_FILE_THRESHOLD_GB) {
+        console.log(`🚨 File is larger than ${LARGE_FILE_THRESHOLD_GB} GB, using unzip for efficiency`);
+        return await extractMeca(mecaPath, outputDir);
+    }
+    else if (selective) {
+        return await extractMecaSelective(mecaPath, outputDir);
+    }
+    else {
+        return await extractMeca(mecaPath, outputDir);
+    }
+}
+async function extractMeca(mecaPath, outputDir) {
+    const extractedDir = path.join(outputDir, path.basename(mecaPath, path.extname(mecaPath)));
+    if (!fs.existsSync(extractedDir)) {
+        fs.mkdirSync(extractedDir, { recursive: true });
+    }
+    // Check if unzip is available
+    const unzipAvailable = await execAsync('which unzip').catch(() => false);
+    if (unzipAvailable) {
+        try {
+            // Use unzip command for file system extraction (handles large files better)
+            const { stderr } = await execAsync(`unzip -q "${mecaPath}" -d "${extractedDir}"`);
+            if (stderr && !stderr.includes('warning')) {
+                console.warn(`  ⚠️  Unzip warnings: ${stderr}`);
+            }
+        }
+        catch (error) {
+            console.error(`  ❌ Unzip failed: ${error}`);
+            throw new Error(`Failed to extract MECA file with unzip: ${error}`);
+        }
+    }
+    else {
+        // Fallback to AdmZip for full extraction
+        const zip = new AdmZip(mecaPath);
+        zip.extractAllTo(extractedDir, true);
+    }
+    return extractedDir;
+}
+async function extractMecaSelective(mecaPath, outputDir) {
+    const extractedDir = path.join(outputDir, path.basename(mecaPath, path.extname(mecaPath)));
+    if (!fs.existsSync(extractedDir)) {
+        fs.mkdirSync(extractedDir, { recursive: true });
+    }
+    console.log('  📦 Using selective extraction (manifest + JATS only)...');
+    // Use adm-zip for selective ZIP extraction
+    const zip = new AdmZip(mecaPath);
+    // First, extract just the manifest to see what's available
+    const manifestEntry = zip.getEntry('manifest.xml');
+    if (!manifestEntry) {
+        throw new Error('Manifest not found in MECA file');
+    }
+    // Extract manifest
+    zip.extractEntryTo('manifest.xml', extractedDir, false, true);
+    console.log('  📋 Manifest extracted');
+    // Parse manifest to find JATS file path from manifest
+    const manifest = await parseManifest(extractedDir);
+    // Find the JATS file path from the manifest (without constructing full path yet)
+    let jatsRelativePath = null;
+    for (const item of manifest.item) {
+        if (item['@_type'] === 'article') {
+            for (const instance of item.instance) {
+                if (instance['@_media-type'] === 'application/xml' &&
+                    instance['@_href'].endsWith('.xml') &&
+                    !instance['@_href'].includes('manifest') &&
+                    !instance['@_href'].includes('directives')) {
+                    // Normalize path separators to Unix style
+                    jatsRelativePath = instance['@_href'].replace(/\\/g, '/');
+                    break;
+                }
+            }
+            if (jatsRelativePath)
+                break;
+        }
+    }
+    if (!jatsRelativePath) {
+        throw new Error('No JATS XML file found in manifest');
+    }
+    console.log(`  📄 Found JATS file in manifest: ${jatsRelativePath}`);
+    // Extract the JATS file using the relative path from manifest
+    const jatsEntry = zip.getEntry(jatsRelativePath) || zip.getEntry(jatsRelativePath.replace(/\//g, '\\'));
+    if (jatsEntry) {
+        console.log(`  🔍 Extracting JATS file: ${jatsRelativePath} to ${extractedDir}`);
+        // Create the target directory structure if it doesn't exist
+        const jatsTargetPath = path.join(extractedDir, jatsRelativePath);
+        const jatsTargetDir = path.dirname(jatsTargetPath);
+        if (!fs.existsSync(jatsTargetDir)) {
+            fs.mkdirSync(jatsTargetDir, { recursive: true });
+            console.log(`  📁 Created directory: ${jatsTargetDir}`);
+        }
+        // Extract the JATS file content and write it to the correct location
+        const jatsContent = jatsEntry.getData();
+        fs.writeFileSync(jatsTargetPath, jatsContent);
+        console.log(`  📄 JATS file extracted: ${path.basename(jatsRelativePath)}`);
+        // Verify the file was extracted successfully
+        console.log(`  🔍 Verifying file exists at: ${jatsTargetPath}`);
+        if (!fs.existsSync(jatsTargetPath)) {
+            // Debug: list what was actually extracted
+            console.log(`  🔍 Debug: Checking extracted directory contents:`);
+            const listExtractedFiles = (dir, prefix = '') => {
+                if (fs.existsSync(dir)) {
+                    const items = fs.readdirSync(dir);
+                    items.forEach((item) => {
+                        const itemPath = path.join(dir, item);
+                        const stat = fs.statSync(itemPath);
+                        if (stat.isDirectory()) {
+                            console.log(`    ${prefix}📁 ${item}/`);
+                            listExtractedFiles(itemPath, prefix + '  ');
+                        }
+                        else {
+                            console.log(`    ${prefix}📄 ${item}`);
+                        }
+                    });
+                }
+            };
+            listExtractedFiles(extractedDir);
+            throw new Error(`JATS file was not extracted successfully to: ${jatsTargetPath}`);
+        }
+        console.log(`  ✅ JATS file verified at: ${jatsTargetPath}`);
+    }
+    else {
+        throw new Error(`Could not extract JATS file: ${jatsRelativePath}`);
+    }
+    return extractedDir;
+}
+async function parseManifest(extractedDir) {
+    const manifestPath = path.join(extractedDir, 'manifest.xml');
+    if (!fs.existsSync(manifestPath)) {
+        throw new Error('Manifest file not found');
+    }
+    let manifestContent = fs.readFileSync(manifestPath, 'utf-8');
+    // Preprocess XML content to fix common HTML entities and reorder XML declaration if needed
+    manifestContent = preprocessXMLContent(manifestContent);
+    // Use xast-util-from-xml to parse the manifest XML
+    const ast = fromXml(manifestContent);
+    // Parse the manifest structure
+    return parseManifestStructure(ast);
+}
+function parseManifestStructure(ast) {
+    // Navigate through the AST to find manifest content
+    const manifest = findElement(ast, 'manifest');
+    if (!manifest) {
+        throw new Error('Manifest element not found');
+    }
+    const items = findElements(manifest, 'item');
+    const itemData = items.map((item) => {
+        const id = getAttribute(item, 'id');
+        const type = getAttribute(item, 'type');
+        const title = getTextContent(item);
+        const instances = findElements(item, 'instance');
+        const instanceData = instances.map((instance) => {
+            const mediaType = getAttribute(instance, 'media-type');
+            const href = getAttribute(instance, 'href');
+            return {
+                '@_media-type': mediaType || '',
+                '@_href': href || '',
+            };
+        });
+        return {
+            '@_id': id || '',
+            '@_type': type || '',
+            '@_title': title || '',
+            instance: instanceData,
+        };
+    });
+    return {
+        item: itemData,
+    };
+}
+function findJATSFile(manifest, extractedDir) {
+    for (const item of manifest.item) {
+        if (item['@_type'] === 'article') {
+            for (const instance of item.instance) {
+                if (instance['@_media-type'] === 'application/xml' &&
+                    instance['@_href'].endsWith('.xml') &&
+                    !instance['@_href'].includes('manifest') &&
+                    !instance['@_href'].includes('directives')) {
+                    // Normalize path separators to Unix style
+                    const normalizedPath = instance['@_href'].replace(/\\/g, '/');
+                    return path.join(extractedDir, normalizedPath);
+                }
+            }
+        }
+    }
+    return null;
+}
+async function parseJATS(jatsFile) {
+    let jatsContent = fs.readFileSync(jatsFile, 'utf-8');
+    // Preprocess XML content to fix common HTML entities
+    jatsContent = preprocessXMLContent(jatsContent);
+    // Use xast-util-from-xml for JATS parsing
+    const ast = fromXml(jatsContent);
+    // Extract metadata from the parsed JATS AST
+    const doi = extractDOI(ast);
+    const versionInfo = extractVersion(ast);
+    const dates = extractDates(ast);
+    const title = extractTitle(ast);
+    return {
+        doi,
+        version: versionInfo.version,
+        articleVersion: versionInfo.articleVersion,
+        receivedDate: dates.receivedDate,
+        acceptedDate: dates.acceptedDate,
+        title,
+    };
+}
+/**
+ * Preprocess XML content to fix common HTML entities that cause parsing errors
+ * @param xmlContent Raw XML content
+ * @returns Preprocessed XML content with entities replaced
+ */
+export function preprocessXMLContent(xmlContent) {
+    // Handle cases where XML declaration is not on the first line or has leading whitespace
+    // Split content into lines and look for XML declaration
+    const lines = xmlContent.split('\n');
+    const xmlDeclarationIndex = lines.findIndex((line) => line.trim().startsWith('<?xml'));
+    if (xmlDeclarationIndex >= 0) {
+        if (xmlDeclarationIndex === 0) {
+            // XML declaration is on first line but may have leading whitespace
+            // Trim the first line to remove leading whitespace
+            lines[0] = lines[0].trim();
+            // Reconstruct the content
+            xmlContent = lines.join('\n');
+        }
+        else if (xmlDeclarationIndex < 5) {
+            // XML declaration is found but not on first line, reorder lines
+            const xmlDeclaration = lines[xmlDeclarationIndex];
+            // Remove the XML declaration from its current position
+            lines.splice(xmlDeclarationIndex, 1);
+            // Insert it at the beginning (without leading whitespace)
+            lines.unshift(xmlDeclaration.trim());
+            // Reconstruct the content
+            xmlContent = lines.join('\n');
+        }
+    }
+    // One specific case in January 2019
+    xmlContent = xmlContent.replace('<fn id="n1"fn-type="equal">', '<fn id="n1" fn-type="equal">');
+    // Define all valid HTML entities that we recognize
+    const validEntities = Object.keys(characterEntities);
+    // First, escape any unescaped ampersands that cause "Unterminated reference" errors
+    // This handles cases like "Bill & Melinda" where & is not properly escaped
+    const validEntityPattern = validEntities.join('|');
+    let processedContent = xmlContent.replace(new RegExp(`&(?!(?:${validEntityPattern}|#\\d+);)`, 'g'), '&#38;');
+    // Now replace HTML entities with their Unicode equivalents
+    // This handles cases like &ndash;, &lt;, etc.
+    // Note: We do NOT convert &amp; to & to avoid circular problems
+    const entityReplacements = {
+        ...Object.fromEntries(Object.entries(characterEntities).map(([key, value]) => [`&${key};`, value])),
+        '&lt;': '&#60;', // less than
+        '&gt;': '&#62;', // greater than
+        '&amp;': '&#38;', // ampersand
+    };
+    // Replace HTML entities
+    for (const [entity, replacement] of Object.entries(entityReplacements)) {
+        processedContent = processedContent.replace(new RegExp(entity, 'g'), replacement);
+    }
+    return processedContent;
+}
+// Helper functions to navigate the XAST
+function findElement(node, name) {
+    if (node.type === 'element' && node.name === name) {
+        return node;
+    }
+    if (node.children) {
+        for (const child of node.children) {
+            if (child.type === 'element') {
+                const found = findElement(child, name);
+                if (found)
+                    return found;
+            }
+        }
+    }
+    return null;
+}
+function findElements(node, name) {
+    const results = [];
+    if (node.type === 'element' && node.name === name) {
+        results.push(node);
+    }
+    if (node.children) {
+        for (const child of node.children) {
+            if (child.type === 'element') {
+                results.push(...findElements(child, name));
+            }
+        }
+    }
+    return results;
+}
+function getAttribute(node, name) {
+    if (node.attributes && node.attributes[name]) {
+        const value = node.attributes[name];
+        return value ? String(value) : null;
+    }
+    return null;
+}
+function extractDOI(ast) {
+    // Look for article-id with pub-id-type="doi"
+    const articleIds = findElements(ast, 'article-id');
+    for (const id of articleIds) {
+        const pubIdType = getAttribute(id, 'pub-id-type');
+        if (pubIdType === 'doi') {
+            // Get the text content
+            const textContent = getTextContent(id);
+            if (textContent) {
+                return textContent.trim();
+            }
+        }
+    }
+    throw new Error('DOI not found in JATS XML');
+}
+function extractVersion(ast) {
+    // Look for article-version
+    const versionElement = findElement(ast, 'article-version');
+    if (versionElement) {
+        const textContent = getTextContent(versionElement);
+        if (textContent) {
+            const version = textContent.trim();
+            // Extract the version number from strings like "1.4" -> articleVersion = 4
+            const versionParts = version.split('.');
+            const articleVersion = versionParts.length > 1 ? parseInt(versionParts[1]) : 1;
+            return { version, articleVersion };
+        }
+    }
+    return { version: '1.1', articleVersion: 1 }; // Default version
+}
+function extractDates(ast) {
+    let receivedDate;
+    let acceptedDate;
+    // Look for dates in history section
+    const history = findElement(ast, 'history');
+    if (history) {
+        const dates = findElements(history, 'date');
+        for (const date of dates) {
+            const dateType = getAttribute(date, 'date-type');
+            const yearElement = findElement(date, 'year');
+            const monthElement = findElement(date, 'month');
+            const dayElement = findElement(date, 'day');
+            if (yearElement && monthElement && dayElement) {
+                const year = getTextContent(yearElement);
+                const month = getTextContent(monthElement);
+                const day = getTextContent(dayElement);
+                if (year && month && day) {
+                    const dateString = `${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`;
+                    if (dateType === 'received') {
+                        receivedDate = dateString;
+                    }
+                    else if (dateType === 'accepted') {
+                        acceptedDate = dateString;
+                    }
+                }
+            }
+        }
+    }
+    // Fallback: look for pub-date with pub-type="epub" (bioRxiv format)
+    if (!receivedDate) {
+        const pubDates = findElements(ast, 'pub-date');
+        for (const date of pubDates) {
+            const pubType = getAttribute(date, 'pub-type');
+            if (pubType === 'epub') {
+                const yearElement = findElement(date, 'year');
+                const monthElement = findElement(date, 'month');
+                const dayElement = findElement(date, 'day');
+                if (yearElement && monthElement && dayElement) {
+                    const year = getTextContent(yearElement);
+                    const month = getTextContent(monthElement);
+                    const day = getTextContent(dayElement);
+                    if (year && month && day) {
+                        receivedDate = `${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    // If no received date found, fall back to accepted date
+    if (!receivedDate) {
+        if (acceptedDate) {
+            console.log(`⚠️  No received date found, falling back to accepted date: ${acceptedDate}`);
+            receivedDate = acceptedDate;
+        }
+        else {
+            throw new Error('Neither received date nor accepted date found in JATS XML');
+        }
+    }
+    return { receivedDate, acceptedDate };
+}
+function extractTitle(ast) {
+    // Look for article-title
+    const titleElement = findElement(ast, 'article-title');
+    if (titleElement) {
+        const textContent = getTextContent(titleElement);
+        if (textContent) {
+            return textContent.trim();
+        }
+    }
+    return undefined;
+}
+function getTextContent(node) {
+    if (node.children) {
+        let text = '';
+        for (const child of node.children) {
+            if (child.type === 'text' && child.value) {
+                text += child.value;
+            }
+            else if (child.type === 'element' && child.children) {
+                const childText = getTextContent(child);
+                if (childText) {
+                    text += childText;
+                }
+            }
+        }
+        return text || null;
+    }
+    return null;
+}
+async function postToAPI(paperData, apiUrl, apiKey) {
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (apiKey) {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+    const response = await axios.post(`${apiUrl}/v1/works`, paperData, { headers });
+    return response.data;
+}

package/dist/utils/meca-processor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=meca-processor.test.d.ts.map

package/dist/utils/meca-processor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meca-processor.test.d.ts","sourceRoot":"","sources":["../../src/utils/meca-processor.test.ts"],"names":[],"mappings":""}

package/dist/utils/meca-processor.test.js

@@ -0,0 +1,123 @@
+import { describe, it, expect, vi } from 'vitest';
+import { preprocessXMLContent } from './meca-processor.js';
+// Mock fs module for testing
+vi.mock('fs', () => ({
+    default: {
+        statSync: vi.fn(),
+        existsSync: vi.fn(),
+        readFileSync: vi.fn(),
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+    },
+}));
+describe('preprocessXMLContent - Ampersand Handling', () => {
+    it.each([
+        {
+            name: 'should escape unescaped ampersands',
+            input: 'Bill & Melinda Gates Foundation',
+            expected: 'Bill & Melinda Gates Foundation',
+        },
+        {
+            name: 'should preserve already escaped ampersands',
+            input: 'Bill & Melinda Gates Foundation',
+            expected: 'Bill & Melinda Gates Foundation',
+        },
+        {
+            name: 'should preserve numeric entities for ampersands',
+            input: 'Bill & Melinda Gates Foundation',
+            expected: 'Bill & Melinda Gates Foundation',
+        },
+        {
+            name: 'should handle mixed ampersand scenarios',
+            input: 'Company & Associates & Partners < 100',
+            expected: 'Company & Associates & Partners < 100',
+        },
+        {
+            name: 'should handle complex academic text with various ampersands',
+            input: 'The Bill & Melinda Gates Foundation & European Commission's Horizon 2020',
+            expected: 'The Bill & Melinda Gates Foundation & European Commission's Horizon 2020',
+        },
+        {
+            name: 'should handle multiple unescaped ampersands in sequence',
+            input: 'A & B & C & D',
+            expected: 'A & B & C & D',
+        },
+        {
+            name: 'should preserve valid HTML entities while escaping unescaped ampersands',
+            input: 'Temperature < 5 °C & Pressure > 100 μPa',
+            expected: 'Temperature < 5 °C & Pressure > 100 μPa',
+        },
+        {
+            name: 'rsquor',
+            input: 'dataset’s terms of use.',
+            expected: 'dataset’s terms of use.',
+        },
+    ])('$name', ({ input, expected }) => {
+        const result = preprocessXMLContent(input);
+        expect(result).toBe(expected);
+    });
+});
+describe('preprocessXMLContent - XML Declaration Reordering', () => {
+    it('should reorder XML declaration to first line when it appears after DOCTYPE', () => {
+        const input = `<!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Archiving and Interchange DTD v1.2d1 20170631//EN" "JATS-archivearticle1.dtd">
+<?xml version="1.0" encoding="UTF-8"?>
+<article xmlns:mml="http://www.w3.org/1998/Math/MathML">
+  <title>Test Article</title>
+</article>`;
+        const result = preprocessXMLContent(input);
+        // Check that XML declaration is now first
+        expect(result.startsWith('<?xml version="1.0" encoding="UTF-8"?>')).toBe(true);
+        // Check that DOCTYPE is second
+        expect(result.includes('<!DOCTYPE article PUBLIC')).toBe(true);
+        // Check that the content is preserved
+        expect(result).toContain('<article xmlns:mml="http://www.w3.org/1998/Math/MathML">');
+        expect(result).toContain('<title>Test Article</title>');
+    });
+    it('should trim leading whitespace from XML declaration on first line', () => {
+        const input = ` <?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Archiving and Interchange DTD v1.2d1 20170631//EN" "JATS-archivearticle1.dtd">
+<article xmlns:mml="http://www.w3.org/1998/Math/MathML">
+  <title>Test Article</title>
+</article>`;
+        const result = preprocessXMLContent(input);
+        // Check that XML declaration is first and has no leading whitespace
+        expect(result.startsWith('<?xml version="1.0" encoding="UTF-8"?>')).toBe(true);
+        // Check that DOCTYPE is second
+        expect(result.includes('<!DOCTYPE article PUBLIC')).toBe(true);
+        // Check that the content is preserved
+        expect(result).toContain('<article xmlns:mml="http://www.w3.org/1998/Math/MathML">');
+        expect(result).toContain('<title>Test Article</title>');
+    });
+    it('should not reorder when XML declaration is already first', () => {
+        const input = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Archiving and Interchange DTD v1.2d1 20170631//EN" "JATS-archivearticle1.dtd">
+<article>
+  <title>Test Article</title>
+</article>`;
+        const result = preprocessXMLContent(input);
+        // Should remain unchanged
+        expect(result).toBe(input);
+    });
+    it('should not reorder when XML declaration is beyond 4th line', () => {
+        const input = `<!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Archiving and Interchange DTD v1.2d1 20170631//EN" "JATS-archivearticle1.dtd">
+<article>
+  <title>Test Article</title>
+  <abstract>This is a test abstract</abstract>
+  <body>Test body content</body>
+<?xml version="1.0" encoding="UTF-8"?>
+</article>`;
+        const result = preprocessXMLContent(input);
+        // Should not reorder since XML declaration is on the 5th line (index 4)
+        // and we only reorder if it's within the first 4 lines (indices 0-3)
+        expect(result).toBe(input);
+    });
+    it('should handle case with no XML declaration', () => {
+        const input = `<!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Archiving and Interchange DTD v1.2d1 20170631//EN" "JATS-archivearticle1.dtd">
+<article>
+  <title>Test Article</title>
+</article>`;
+        const result = preprocessXMLContent(input);
+        // Should remain unchanged
+        expect(result).toBe(input);
+    });
+});

package/dist/utils/months.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Month utility functions for batch processing
+ */
+/**
+ * Generate a range of months to process backwards from current month to 2018-12
+ */
+export declare function generateMonthRange(): string[];
+/**
+ * Parse month input and return array of months to process
+ */
+export declare function parseMonthInput(monthInput: string): string[];
+/**
+ * Parse wildcard pattern like "2025-*" to get all months in that year
+ */
+export declare function parseWildcardPattern(pattern: string): string[];
+/**
+ * Validate month format (YYYY-MM)
+ */
+export declare function validateMonthFormat(month: string): boolean;
+/**
+ * Sort months chronologically (oldest first)
+ */
+export declare function sortMonthsChronologically(months: string[]): string[];
+/**
+ * Get current month in YYYY-MM format
+ */
+export declare function getCurrentMonth(): string;
+/**
+ * Get previous month in YYYY-MM format
+ */
+export declare function getPreviousMonth(): string;
+/**
+ * Check if a month is in the future
+ */
+export declare function isFutureMonth(month: string): boolean;
+//# sourceMappingURL=months.d.ts.map

package/dist/utils/months.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"months.d.ts","sourceRoot":"","sources":["../../src/utils/months.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAuB7C;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CA6B5D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAwB9D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAW1D;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAUpE;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAKxC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAMzC;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAOpD"}