node-nim 10.9.70 → 10.9.71-beta.69

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-nim",
-    "version": "10.9.70",
+    "version": "10.9.71-beta.69",
     "description": "NetEase IM nodejs wrapper based on NetEase IM C++ SDK",
     "main": "dist/node-nim.js",
     "bin": {
@@ -33,10 +33,11 @@
         ]
     },
     "dependencies": {
-        "compare-versions": "^4.1.4",
-        "download": "^8.0.0",
         "eventemitter3": "^4.0.7",
-        "node-fetch": "^2.6.9"
+        "compare-versions": "^4.1.4",
+        "node-fetch": "^2.6.9",
+        "yauzl": "^2.10.0",
+        "tar": "^6.2.0"
     },
     "devDependencies": {
         "@babel/preset-env": "^7.24.0",

package/script/download-sdk.js

@@ -2,7 +2,11 @@ const fetch = require('node-fetch')
 const fs = require('fs')
 const path = require('path')
 const compareVersions = require('compare-versions')
-const download = require('download')
+const yauzl = require('yauzl')
+const tar = require('tar')
+const { pipeline } = require('stream')
+const { promisify } = require('util')
+const pipelineAsync = promisify(pipeline)
 
 // Global variables
 const default_arch = 'universal'
@@ -25,6 +29,117 @@ if (process.env.npm_package_version) {
 if (process.env.npm_config_nimsdkversion) {
     version = process.env.npm_config_nimsdkversion
 }
+
+// Download and extract function to replace the 'download' package
+async function downloadAndExtract(url, destination) {
+    if (!fs.existsSync(destination)) {
+        fs.mkdirSync(destination, { recursive: true })
+    }
+
+    // Download the file
+    const response = await fetch(url)
+    if (!response.ok) {
+        throw new Error(`Failed to download: ${response.statusText}`)
+    }
+
+    // Determine file type from URL
+    const isZip = url.toLowerCase().includes('.zip')
+    const isTarGz = url.toLowerCase().includes('.tar.gz') || url.toLowerCase().includes('.tgz')
+
+    let archivePath
+    let fileExtension
+
+    if (isZip) {
+        fileExtension = '.zip'
+        archivePath = path.join(destination, 'temp.zip')
+    } else if (isTarGz) {
+        fileExtension = '.tar.gz'
+        archivePath = path.join(destination, 'temp.tar.gz')
+    } else {
+        // Default to zip if we can't determine the type
+        fileExtension = '.zip'
+        archivePath = path.join(destination, 'temp.zip')
+        console.warn('[node-nim] Could not determine archive type from URL, assuming ZIP format')
+    }
+
+    // Save the downloaded file
+    const writeStream = fs.createWriteStream(archivePath)
+    await pipelineAsync(response.body, writeStream)
+
+    // Extract based on file type
+    if (isTarGz) {
+        await extractTarGz(archivePath, destination)
+    } else {
+        await extractZip(archivePath, destination)
+    }
+
+    // Clean up the temporary archive file
+    fs.unlinkSync(archivePath)
+}
+
+// Extract ZIP files
+async function extractZip(zipPath, destination) {
+    return new Promise((resolve, reject) => {
+        yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
+            if (err) return reject(err)
+
+            zipfile.readEntry()
+            zipfile.on('entry', (entry) => {
+                // Filter out macOS hidden files (._files)
+                if (entry.fileName.includes('._')) {
+                    zipfile.readEntry()
+                    return
+                }
+
+                if (/\/$/.test(entry.fileName)) {
+                    // Directory entry
+                    const dirPath = path.join(destination, entry.fileName)
+                    fs.mkdirSync(dirPath, { recursive: true })
+                    zipfile.readEntry()
+                } else {
+                    // File entry
+                    zipfile.openReadStream(entry, (err, readStream) => {
+                        if (err) return reject(err)
+
+                        const filePath = path.join(destination, entry.fileName)
+                        const fileDir = path.dirname(filePath)
+
+                        if (!fs.existsSync(fileDir)) {
+                            fs.mkdirSync(fileDir, { recursive: true })
+                        }
+
+                        const writeStream = fs.createWriteStream(filePath)
+                        readStream.pipe(writeStream)
+
+                        writeStream.on('close', () => {
+                            zipfile.readEntry()
+                        })
+
+                        writeStream.on('error', reject)
+                    })
+                }
+            })
+
+            zipfile.on('end', () => {
+                resolve()
+            })
+
+            zipfile.on('error', reject)
+        })
+    })
+}
+
+// Extract TAR.GZ files
+async function extractTarGz(tarPath, destination) {
+    return tar.extract({
+        file: tarPath,
+        cwd: destination,
+        filter: (path, entry) => {
+            // Filter out macOS hidden files (._files)
+            return !path.includes('/._') && !path.startsWith('._')
+        }
+    })
+}
 async function downloadSDK(custom_sdk_url) {
     if (custom_sdk_url) {
         downloadUrl = custom_sdk_url
@@ -74,12 +189,8 @@ async function downloadSDK(custom_sdk_url) {
     }
     // download sdk
     try {
-        await download(downloadUrl, savePath, {
-            extract: true,
-            filter: (file) => {
-                return !file.path.includes('._')
-            }
-        })
+        await downloadAndExtract(downloadUrl, savePath)
+
         // create build/Release folder
         if (!fs.existsSync(target)) {
             fs.mkdirSync(target, { recursive: true })