minnan-zhangzhou-admin/scripts/UpdateScript/utils.mjs

import fs from 'fs';
import { ZipArchive } from 'archiver';
import { exec } from 'child_process';
import { readdir, stat } from 'fs/promises';
import consola from 'consola';

export function readFileRange(file, start, length) {
  return new Promise((resolve, reject) => {
    fs.open(file, 'r', (err, fd) => {
      if (err) {
        reject('Error opening file:', er);
        return;
      }
      const buffer = Buffer.alloc(length);
      fs.read(fd, buffer, 0, length, start, (err, bytesRead, buffer) => {
        if (err) {
          reject('Error reading file:', err)
          return;
        }
        fs.close(fd, (err) => {
          if (err) {
            reject('Error closing file:', err)
            return ;
          }
          resolve(buffer);
        });
      });
    });
  })
  
}
export function pad(num, n) {
  var strNum = num.toString();
  var len = strNum.length;
  while (len < n) {
    strNum = "0" + strNum;
    len++;
  }
  return strNum;
}

/**
 * 异步执行命令
 * @param {string} command 命令
 * @returns {Promise<string>} 命令执行结果
 */
export function execAsync(command) {
  return new Promise((resolve, reject) => {
    consola.info('[CMD] ' + command);
    exec(command, (error, stdout, stderr) => {
      if (error) {
        reject(error);
        return;
      }
      resolve(stdout);
    });
  })
}

/**
 * 记录错误信息
 * @param {string} message 错误信息
 * @param {*} e 错误对象
 */
export function logError(message, e) {
  consola.error(message, e || '');
}

/**
 * 获取错误信息
 * @param {*} e 错误对象
 * @returns {string} 错误信息
 */
export function getErrorMessage(e) {
  if (e instanceof Error) 
    return e.message;
  if (typeof e === 'object' && e.message)
    return e.message;
  return '' + e;
}

/**
 * 压缩zip
 * @param {string} dir 压缩目录
 * @param {string} targetFilePath 压缩文件路径
 * @param {string[]} skipFiles 压缩忽略文件 支持按开头匹配，和文件类型通配符匹配，如：'*.js', '*.css', '*.html'
 * @returns {Promise<void>}
 */
export async function compressZip(dir, targetFilePath, skipFiles) {
  const output = fs.createWriteStream(targetFilePath);
  const archive = new ZipArchive({
    zlib: { level: 9 } // Sets the compression level.
  });
  archive.pipe(output);

  function checkPathSkip(pathString) {
    if (!pathString)
      return true;
    if (pathString.startsWith('.') || pathString.startsWith('/.'))
      return true;
    if (!skipFiles || skipFiles.length === 0)
      return;
    return skipFiles.find((item) => (
      pathString.startsWith(item) || pathString.startsWith(`/${item}`)
      || (item.includes('*.') && pathString.endsWith(item.split('*')[1]))
    ));
  }

  async function loopDir(path, subPrefix) {
    const files = await readdir(path);
    for (const file of files) {
      const subPath = subPrefix + '/' + file;
      if (checkPathSkip(subPath))
        continue;
      consola.info('File: ' + subPath);
      const filestat = await stat(dir + subPath);
      if (filestat.isDirectory()) {
        await loopDir(dir + subPath, subPath);
      } else {
        archive.file(dir + subPath, { name: subPath });
      }
    }
  }
  await loopDir(dir, '')

  consola.start('等待压缩zip...');

  const waitArchive = new Promise((resolve, reject) => {
    output.on('close', function() {
      consola.info(archive.pointer() + ' total bytes');
      consola.success('archiver has been finalized and the output file descriptor has closed.');
      resolve();
    });
    archive.on('error', function(err) {
      reject(err);
    });
  })

  await archive.finalize();
  await waitArchive;
}