node-pdf2img 0.1.5 → 0.1.7

package/README.md

@@ -157,6 +157,32 @@ const result = await convert('./document.pdf', {
 });
 ```
 
+### pages 参数说明
+
+`pages` 参数控制要转换的页面：
+
+- **空数组 `[]` 或不传**：转换所有页面
+- **指定页码数组**：只转换指定页面（1-based）
+
+```javascript
+// 转换所有页面（推荐）
+await convert('./document.pdf', { pages: [] });
+
+// 只转换第 1、3、5 页
+await convert('./document.pdf', { pages: [1, 3, 5] });
+```
+
+> **最佳实践**：如果需要转换所有页面，直接使用 `convert()` 并传空 `pages` 数组，**不要**先调用 `getPageCount()` 获取页数再传入。这样可以避免 URL 输入时重复下载 PDF 文件。
+>
+> ```javascript
+> // ❌ 不推荐：URL 会被下载两次
+> const pageCount = await getPageCount(url);
+> const result = await convert(url, { pages: Array.from({length: pageCount}, (_, i) => i + 1) });
+>
+> // ✅ 推荐：直接转换所有页面
+> const result = await convert(url, { pages: [] });
+> ```
+
 ### 自定义渲染宽度
 
 ```javascript

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-pdf2img",
-    "version": "0.1.5",
+    "version": "0.1.7",
     "description": "High-performance PDF to image converter using PDFium native renderer",
     "type": "module",
     "main": "./src/index.js",
@@ -55,7 +55,7 @@
         "p-limit": "^7.2.0",
         "piscina": "^5.1.4",
         "sharp": "^0.33.0",
-        "node-pdf2img-native": "^1.1.6"
+        "node-pdf2img-native": "^1.1.8"
     },
     "devDependencies": {
         "@types/node": "^20.0.0"

package/src/core/converter.js

@@ -424,6 +424,59 @@ export async function convert(input, options = {}) {
     // 使用线程池渲染页面
     const result = await renderPages(input, inputType, pages, encodeOptions);
 
+    // 恢复 Buffer 类型
+    // Piscina 跨线程传递时 Buffer 可能被序列化为普通对象 { type: 'Buffer', data: [...] }
+    const normalizedPages = result.pages.map(page => {
+        if (!page.success || !page.buffer) {
+            return {
+                pageNum: page.pageNum,
+                width: page.width,
+                height: page.height,
+                success: false,
+                buffer: null,
+                error: page.error || 'Render failed',
+            };
+        }
+
+        let buffer = page.buffer;
+        if (!Buffer.isBuffer(buffer)) {
+            try {
+                if (buffer && typeof buffer === 'object') {
+                    if (buffer.type === 'Buffer' && Array.isArray(buffer.data)) {
+                        buffer = Buffer.from(buffer.data);
+                    } else if (buffer.data && ArrayBuffer.isView(buffer.data)) {
+                        buffer = Buffer.from(buffer.data);
+                    } else if (ArrayBuffer.isView(buffer)) {
+                        buffer = Buffer.from(buffer);
+                    } else {
+                        buffer = Buffer.from(buffer);
+                    }
+                } else {
+                    throw new Error(`Cannot convert ${typeof buffer} to Buffer`);
+                }
+            } catch (e) {
+                logger.error(`Buffer type mismatch: ${typeof page.buffer}, conversion failed: ${e.message}`);
+                return {
+                    pageNum: page.pageNum,
+                    width: page.width,
+                    height: page.height,
+                    success: false,
+                    buffer: null,
+                    error: `Invalid buffer type returned from worker: ${e.message}`,
+                };
+            }
+        }
+
+        return {
+            pageNum: page.pageNum,
+            width: page.width,
+            height: page.height,
+            success: true,
+            buffer,
+            size: buffer.length,
+        };
+    });
+
     // 处理输出
     let outputResult;
 
@@ -431,72 +484,17 @@ export async function convert(input, options = {}) {
         if (!outputDir) {
             throw new Error('outputDir is required when outputType is "file"');
         }
-        outputResult = await saveToFiles(result.pages, outputDir, prefix, normalizedFormat, concurrency);
+        outputResult = await saveToFiles(normalizedPages, outputDir, prefix, normalizedFormat, concurrency);
 
     } else if (outputType === OutputType.COS) {
         if (!cosConfig) {
             throw new Error('cos config is required when outputType is "cos"');
         }
-        outputResult = await uploadToCos(result.pages, cosConfig, cosKeyPrefix, normalizedFormat, concurrency);
+        outputResult = await uploadToCos(normalizedPages, cosConfig, cosKeyPrefix, normalizedFormat, concurrency);
 
     } else {
         // 返回 Buffer
-        outputResult = result.pages.map(page => {
-            if (!page.success || !page.buffer) {
-                return {
-                    pageNum: page.pageNum,
-                    width: page.width,
-                    height: page.height,
-                    success: false,
-                    buffer: null,
-                    error: page.error || 'Render failed',
-                };
-            }
-
-            // 确保 buffer 是 Buffer 类型
-            // Piscina 跨线程传递时 Buffer 可能被序列化为普通对象
-            let buffer = page.buffer;
-            if (!Buffer.isBuffer(buffer)) {
-                // 尝试从序列化的对象恢复 Buffer
-                try {
-                    if (buffer && typeof buffer === 'object') {
-                        // 可能是 { type: 'Buffer', data: [...] } 格式
-                        if (buffer.type === 'Buffer' && Array.isArray(buffer.data)) {
-                            buffer = Buffer.from(buffer.data);
-                        } else if (buffer.data && ArrayBuffer.isView(buffer.data)) {
-                            buffer = Buffer.from(buffer.data);
-                        } else if (ArrayBuffer.isView(buffer)) {
-                            // Uint8Array 等 TypedArray
-                            buffer = Buffer.from(buffer);
-                        } else {
-                            // 最后尝试直接转换
-                            buffer = Buffer.from(buffer);
-                        }
-                    } else {
-                        throw new Error(`Cannot convert ${typeof buffer} to Buffer`);
-                    }
-                } catch (e) {
-                    logger.error(`Buffer type mismatch: ${typeof page.buffer}, conversion failed: ${e.message}`);
-                    return {
-                        pageNum: page.pageNum,
-                        width: page.width,
-                        height: page.height,
-                        success: false,
-                        buffer: null,
-                        error: `Invalid buffer type returned from worker: ${e.message}`,
-                    };
-                }
-            }
-
-            return {
-                pageNum: page.pageNum,
-                width: page.width,
-                height: page.height,
-                success: true,
-                buffer,
-                size: buffer.length,
-            };
-        }).sort((a, b) => a.pageNum - b.pageNum);
+        outputResult = normalizedPages.sort((a, b) => a.pageNum - b.pageNum);
     }
 
     return {
@@ -519,7 +517,7 @@ export async function convert(input, options = {}) {
 /**
  * 获取 PDF 页数（异步版本）
  *
- * @param {string|Buffer} input - PDF 输入（文件路径或 Buffer）
+ * @param {string|Buffer} input - PDF 输入（文件路径、URL 或 Buffer）
  * @returns {Promise<number>} 页数
  */
 export async function getPageCount(input) {
@@ -532,6 +530,23 @@ export async function getPageCount(input) {
     }
     
     if (typeof input === 'string') {
+        // 检查是否是 URL
+        if (input.startsWith('http://') || input.startsWith('https://')) {
+            // URL 输入：下载到临时文件后获取页数
+            const tempFile = await downloadToTempFile(input);
+            try {
+                return nativeRenderer.getPageCountFromFile(tempFile);
+            } finally {
+                // 清理临时文件
+                try {
+                    await fs.promises.unlink(tempFile);
+                } catch {
+                    // 忽略清理错误
+                }
+            }
+        }
+        
+        // 本地文件路径
         try {
             await fs.promises.access(input, fs.constants.R_OK);
         } catch {
@@ -540,7 +555,7 @@ export async function getPageCount(input) {
         return nativeRenderer.getPageCountFromFile(input);
     }
     
-    throw new Error('Invalid input: must be a file path or Buffer');
+    throw new Error('Invalid input: must be a file path, URL, or Buffer');
 }
 
 /**

package/src/index.d.ts

@@ -92,10 +92,10 @@ export function convert(input: string | Buffer, options?: ConvertOptions): Promi
 /**
  * 获取 PDF 页数
  *
- * @param input - PDF 文件路径或 Buffer
+ * @param input - PDF 文件路径、URL 或 Buffer
  * @returns 页数
  */
-export function getPageCount(input: string | Buffer): number;
+export function getPageCount(input: string | Buffer): Promise<number>;
 
 /**
  * 检查原生渲染器是否可用