w-zip 1.0.21 → 1.0.23

package/src/m7z.mjs

@@ -13,13 +13,13 @@ import checkTarget from './checkTarget.mjs'
  * @example
  * import wz from 'w-zip'
  *
- * let fpUnzip = './testData/output7z'
+ * let fpUnzip = './test/output7z'
  * let fpUnzipExtract = fpUnzip + '/extract'
  *
- * let fpSrc1 = './testData/input/file1(中文).txt'
+ * let fpSrc1 = './test/input/file1(中文).txt'
  * let fpZip1 = fpUnzip + '/test1.7z'
  *
- * let fpSrc2 = './testData/input/folder1'
+ * let fpSrc2 = './test/input/folder1'
  * let fpZip2 = fpUnzip + '/test2.7z'
  * let fpZip2PW = fpUnzip + '/test2PW.7z'
  * let pw = 'abc'
@@ -119,7 +119,7 @@ function m7z() {
     }
 
 
-    async function zip(fpSrc, fpTar, level = 9, pw = '') {
+    async function zip(fpSrc, fpTar, level = 1, pw = '') { //7z的-mx1為最快速壓縮(mx0為不壓縮)
         let arg = [
             'a',
             fpTar,
@@ -141,8 +141,8 @@ function m7z() {
      * @param {String} fpSrc 輸入壓縮來源檔案位置字串
      * @param {String} fpTar 輸入壓縮目標檔案位置字串
      * @param {Object} [opt={}] 輸入設定物件，預設{}
-     * @param {Integer} [opt.level] 輸入壓縮程度整數，範圍為0至9，0為不壓縮而9為最高壓縮，預設9
-     * @param {String} [opt.pw] 輸入壓縮密碼字串，預設''
+     * @param {Integer} [opt.level=1] 輸入壓縮程度整數，範圍為0至9，0為不壓縮而9為最高壓縮，預設1為最快速壓縮
+     * @param {String} [opt.pw=''] 輸入壓縮密碼字串，預設''
      * @returns {Promise} 回傳Promise，resolve為成功資訊，reject為失敗資訊
      */
     async function zipFile(fpSrc, fpTar, opt = {}) {
@@ -161,7 +161,7 @@ function m7z() {
         }
 
         //default
-        let level = get(opt, 'level', 9)
+        let level = get(opt, 'level', 1)
         let pw = get(opt, 'pw', '')
 
         //r
@@ -190,7 +190,7 @@ function m7z() {
      * @param {String} fpSrc 輸入壓縮來源資料夾位置字串
      * @param {String} fpTar 輸入壓縮目標資料夾位置字串
      * @param {Object} [opt={}] 輸入設定物件，預設{}
-     * @param {Integer} [opt.level] 輸入壓縮程度整數，範圍為0至9，0為不壓縮而9為最高壓縮，預設9
+     * @param {Integer} [opt.level=1] 輸入壓縮程度整數，範圍為0至9，0為不壓縮而9為最高壓縮，預設1為最快速壓縮
      * @param {String} [opt.pw] 輸入壓縮密碼字串，預設''
      * @returns {Promise} 回傳Promise，resolve為成功資訊，reject為失敗資訊
      */
@@ -210,7 +210,7 @@ function m7z() {
         }
 
         //default
-        let level = get(opt, 'level', 9)
+        let level = get(opt, 'level', 1)
         let pw = get(opt, 'pw', '')
 
         //r
@@ -274,7 +274,7 @@ function m7z() {
         let error = null
         let r = await execProcess(prog, arg)
             .catch((err) => {
-                error = err
+                error = err.toString()
             })
 
         //check

package/src/mZip.mjs

@@ -1,17 +1,14 @@
 import path from 'path'
 import fs from 'fs'
-import archiver from 'archiver'
-import archiverEnc from 'archiver-zip-encrypted'
-import unzipper from 'unzipper'
-import get from 'lodash-es/get.js'
-import genPm from 'wsemi/src/genPm.mjs'
-import pmMap from 'wsemi/src/pmMap.mjs'
+import { configure, ZipWriter, ZipReader, Uint8ArrayReader, Uint8ArrayWriter } from '@zip.js/zip.js'
+import get from 'lodash-es/get.js'
+import fsTreeFolder from 'wsemi/src/fsTreeFolder.mjs'
 import getFileName from 'wsemi/src/getFileName.mjs'
 import checkTarget from './checkTarget.mjs'
 
 
-//registerFormat
-archiver.registerFormat('zip-encrypted', archiverEnc)
+//configure
+configure({ useWebWorkers: false }) //關閉web worker改用主執行緒壓縮, 確保nodejs下無殘留worker導致process無法結束
 
 
 /**
@@ -22,13 +19,13 @@ archiver.registerFormat('zip-encrypted', archiverEnc)
  * @example
  * import wz from 'w-zip'
  *
- * let fpUnzip = './testData/outputZip'
+ * let fpUnzip = './test/outputZip'
  * let fpUnzipExtract = fpUnzip + '/extract'
  *
- * let fpSrc1 = './testData/input/file1(中文).txt'
+ * let fpSrc1 = './test/input/file1(中文).txt'
  * let fpZip1 = fpUnzip + '/test1.zip'
  *
- * let fpSrc2 = './testData/input/folder1'
+ * let fpSrc2 = './test/input/folder1'
  * let fpZip2 = fpUnzip + '/test2.zip'
  * let fpZip2PW = fpUnzip + '/test2PW.zip'
  * let pw = 'abc'
@@ -100,7 +97,7 @@ function mZip() {
      * @param {String} fpSrc 輸入壓縮來源檔案位置字串
      * @param {String} fpTar 輸入壓縮目標檔案位置字串
      * @param {Object} [opt={}] 輸入設定物件，預設{}
-     * @param {Integer} [opt.level] 輸入壓縮程度整數，範圍為0至9，0為不壓縮而9為最高壓縮，預設9
+     * @param {Integer} [opt.level=9] 輸入壓縮程度整數，範圍為0至9，0為不壓縮而9為最高壓縮，預設9
      * @param {String} [opt.pw] 輸入壓縮密碼字串，預設''
      * @returns {Promise} 回傳Promise，resolve為成功資訊，reject為失敗資訊
      */
@@ -125,54 +122,32 @@ function mZip() {
 
         try {
 
-            //pm
-            let pm = genPm()
-
             //check
             if (!fs.existsSync(path.dirname(fpTar))) {
                 fs.mkdirSync(path.dirname(fpTar), { recursive: true })
             }
 
-            //archiver
-            let output = fs.createWriteStream(fpTar)
-            let archive
-            if (pw === '') {
-                archive = archiver('zip', {
-                    zlib: { level },
-                })
-            }
-            else {
-                archive = archiver('zip-encrypted', {
-                    zlib: { level },
-                    encryptionMethod: 'zip20', //只能用zip20, 因unzipper目前不支援aes256
-                    password: pw,
-                })
+            //zipOpt
+            let zipOpt = { level }
+            if (pw !== '') {
+                zipOpt.password = pw
+                zipOpt.zipCrypto = true //使用ZipCrypto(即zip20)加密維持與舊版相同相容性, 若需更強加密可改為encryptionStrength: 3(AES-256)
             }
 
-            output.on('close', function() {
-                //console.log(archive.pointer() + ' total bytes')
-
-                //resolve
-                pm.resolve('done: ' + fpTar)
+            //zipWriter
+            let zipWriter = new ZipWriter(new Uint8ArrayWriter(), zipOpt)
 
-            })
-            archive.on('warning', function(warn) {
-                //console.log('warning', warn)
-            })
-            archive.on('error', function(err) {
-                Promise.reject(err)
-            })
+            //add
+            let b = fs.readFileSync(fpSrc)
+            await zipWriter.add(path.basename(fpSrc), new Uint8ArrayReader(b))
 
-            //pipe
-            archive.pipe(output)
+            //close
+            let u8 = await zipWriter.close()
 
-            //file
-            archive.file(fpSrc, { name: path.basename(fpSrc) })
+            //writeFileSync
+            fs.writeFileSync(fpTar, u8)
 
-            //finalize
-            archive.finalize()
-
-            return pm
+            return Promise.resolve('done: ' + fpTar)
         }
         catch (err) {
             return Promise.reject(err)
@@ -210,54 +185,57 @@ function mZip() {
 
         try {
 
-            //pm
-            let pm = genPm()
-
             //check
             if (!fs.existsSync(path.dirname(fpTar))) {
                 fs.mkdirSync(path.dirname(fpTar), { recursive: true })
             }
 
-            //archiver
-            let output = fs.createWriteStream(fpTar)
-            let archive
-            if (pw === '') {
-                archive = archiver('zip', {
-                    zlib: { level },
-                })
-            }
-            else {
-                archive = archiver('zip-encrypted', {
-                    zlib: { level },
-                    encryptionMethod: 'zip20', //只能用zip20, 因unzipper目前不支援aes256
-                    password: pw,
-                })
+            //zipOpt
+            let zipOpt = { level }
+            if (pw !== '') {
+                zipOpt.password = pw
+                zipOpt.zipCrypto = true //使用ZipCrypto(即zip20)加密維持與舊版相同相容性, 若需更強加密可改為encryptionStrength: 3(AES-256)
             }
 
-            output.on('close', function() {
-                //console.log(archive.pointer() + ' total bytes')
+            //zipWriter
+            let zipWriter = new ZipWriter(new Uint8ArrayWriter(), zipOpt)
 
-                //resolve
-                pm.resolve('done: ' + fpTar)
+            //bn, 以來源資料夾名稱為zip內根目錄(同archiver.directory(fpSrc, basename)行為)
+            let bn = path.basename(fpSrc)
 
-            })
-            archive.on('warning', function(warn) {
-                //console.log('warning', warn)
-            })
-            archive.on('error', function(err) {
-                Promise.reject(err)
-            })
+            //items, 遞迴列舉資料夾下全部檔案與子資料夾
+            let items = fsTreeFolder(fpSrc, null)
 
-            //pipe
-            archive.pipe(output)
+            //add
+            for (let item of items) {
 
-            //directory
-            archive.directory(fpSrc, path.basename(fpSrc))
+                //name, zip內相對路徑統一用'/'
+                let rel = path.relative(fpSrc, item.path)
+                let name = path.join(bn, rel).replaceAll('\\', '/')
+
+                if (item.isFolder) {
+
+                    //directory, 保留空資料夾結構
+                    await zipWriter.add(name, undefined, { directory: true })
+
+                }
+                else {
 
-            //finalize
-            archive.finalize()
+                    //file
+                    let b = fs.readFileSync(item.path)
+                    await zipWriter.add(name, new Uint8ArrayReader(b))
 
-            return pm
+                }
+
+            }
+
+            //close
+            let u8 = await zipWriter.close()
+
+            //writeFileSync
+            fs.writeFileSync(fpTar, u8)
+
+            return Promise.resolve('done: ' + fpTar)
         }
         catch (err) {
             return Promise.reject(err)
@@ -293,67 +271,54 @@ function mZip() {
         //default
         let pw = get(opt, 'pw', '')
 
-        //extract
-        async function extract(fpSrc, fpTar, password) {
-
-            //mkdir
-            async function mkdir(fd) {
-                try {
-
-                    //check
-                    if (!fs.existsSync(fd)) {
-                        fs.mkdirSync(fd, { recursive: true })
-                    }
+        try {
 
-                }
-                catch (err) {
-                    return Promise.reject(err)
-                }
-                return 'done'
+            //readerOpt
+            let readerOpt = {}
+            if (pw !== '') {
+                readerOpt.password = pw
             }
 
-            //extractFile
-            async function extractFile(file, fn, password = '') {
-                try {
+            //zipReader
+            let b = fs.readFileSync(fpSrc)
+            let zipReader = new ZipReader(new Uint8ArrayReader(b), readerOpt)
 
-                    //check
-                    if (!fs.existsSync(path.dirname(fn))) {
-                        fs.mkdirSync(path.dirname(fn), { recursive: true })
-                    }
+            //entries
+            let entries = await zipReader.getEntries()
 
-                    //buffer
-                    let b = await file.buffer(password)
+            //extract
+            for (let entry of entries) {
 
-                    //writeFileSync
-                    fs.writeFileSync(fn, b)
+                //p, 解壓目標位置
+                let p = path.join(fpTar, entry.filename)
 
-                }
-                catch (err) {
-                    return Promise.reject(err)
-                }
-                return 'done'
-            }
+                if (entry.directory) {
 
-            //directory
-            let directory = await unzipper.Open.file(fpSrc)
+                    //mkdir
+                    if (!fs.existsSync(p)) {
+                        fs.mkdirSync(p, { recursive: true })
+                    }
 
-            //pmMap
-            return pmMap(directory.files, async (file) => {
-                let p = path.join(fpTar, file.path)
-                if (file.type === 'File') {
-                    return extractFile(file, p, password)
                 }
                 else {
-                    return mkdir(p)
-                }
-            })
 
-        }
+                    //mkdir, 先建立上層資料夾
+                    if (!fs.existsSync(path.dirname(p))) {
+                        fs.mkdirSync(path.dirname(p), { recursive: true })
+                    }
 
-        try {
+                    //getData
+                    let u8 = await entry.getData(new Uint8ArrayWriter())
 
-            //extract
-            await extract(fpSrc, fpTar, pw)
+                    //writeFileSync
+                    fs.writeFileSync(p, u8)
+
+                }
+
+            }
+
+            //close
+            await zipReader.close()
 
             return Promise.resolve('done: ' + getFileName(fpTar))
         }

package/test/7z.test.mjs

@@ -15,13 +15,13 @@ describe('7z', function() {
         return
     }
 
-    let fpUnzip = './testData/output7z'
+    let fpUnzip = './test/output7z'
     let fpUnzipExtract = fpUnzip + '/extract'
 
-    let fpSrc1 = './testData/input/file1(中文).txt'
+    let fpSrc1 = './test/input/file1(中文).txt'
     let fpZip1 = fpUnzip + '/test1.7z'
 
-    let fpSrc2 = './testData/input/folder1'
+    let fpSrc2 = './test/input/folder1'
     let fpZip2 = fpUnzip + '/test2.7z'
     let fpZip2PW = fpUnzip + '/test2PW.7z'
     let pw = 'abc'

package/test/zip.test.mjs

@@ -10,13 +10,13 @@ import wz from '../src/WZip.mjs'
 
 describe('zip', function() {
 
-    let fpUnzip = './testData/outputZip'
+    let fpUnzip = './test/outputZip'
     let fpUnzipExtract = fpUnzip + '/extract'
 
-    let fpSrc1 = './testData/input/file1(中文).txt'
+    let fpSrc1 = './test/input/file1(中文).txt'
     let fpZip1 = fpUnzip + '/test1.zip'
 
-    let fpSrc2 = './testData/input/folder1'
+    let fpSrc2 = './test/input/folder1'
     let fpZip2 = fpUnzip + '/test2.zip'
     let fpZip2PW = fpUnzip + '/test2PW.zip'
     let pw = 'abc'

package/toolg/gDistRollup.mjs

@@ -15,17 +15,13 @@ rollupFiles({
         'path': 'path',
         'fs': 'fs',
         'child_process': 'child_process',
-        'archiver': 'archiver',
-        'archiver-zip-encrypted': 'archiver-zip-encrypted',
-        'unzipper': 'unzipper',
+        '@zip.js/zip.js': 'zip',
     },
     external: [
         'path',
         'fs',
         'child_process',
-        'archiver',
-        'archiver-zip-encrypted',
-        'unzipper',
+        '@zip.js/zip.js',
     ],
 })