vite-plugin-deploy-ftp 1.2.2 → 2.0.0

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "vite-plugin-deploy-ftp",
-  "version": "1.2.2",
+  "version": "2.0.0",
   "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "type": "module",
   "homepage": "https://github.com/yulin96/vite-plugin-deploy-ftp",
   "repository": {
     "type": "git",
-    "url": "https://github.com/yulin96/vite-plugin-deploy-ftp"
+    "url": "git+https://github.com/yulin96/vite-plugin-deploy-ftp.git"
   },
   "bugs": {
     "url": "https://github.com/yulin96/vite-plugin-deploy-ftp/issues"
   },
   "exports": {
     ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
   "keywords": [
@@ -49,7 +49,9 @@
   },
   "scripts": {
     "build": "tsup",
+    "typecheck": "tsc -p tsconfig.json",
     "pack": "pnpm run build && pnpm pack",
-    "build:test": "cd playground && vite build"
+    "build:test": "cd playground && vite build",
+    "build:test:deploy": "cd playground && vite build --mode deploy"
   }
 }

package/dist/index.d.mts

@@ -1,41 +0,0 @@
-import { Plugin } from 'vite';
-
-type vitePluginDeployFtpOption = ({
-    uploadPath: string;
-    singleBackFiles?: string[];
-    singleBack?: boolean;
-    open?: boolean;
-    maxRetries?: number;
-    retryDelay?: number;
-    showBackFile?: boolean;
-    autoUpload?: boolean;
-} & {
-    ftps: {
-        name: string;
-        host?: string;
-        port?: number;
-        user?: string;
-        password?: string;
-        alias?: string;
-    }[];
-    defaultFtp?: string;
-}) | ({
-    uploadPath: string;
-    singleBackFiles?: string[];
-    singleBack?: boolean;
-    open?: boolean;
-    maxRetries?: number;
-    retryDelay?: number;
-    showBackFile?: boolean;
-    autoUpload?: boolean;
-} & {
-    name?: string;
-    host?: string;
-    port?: number;
-    user?: string;
-    password?: string;
-    alias?: string;
-});
-declare function vitePluginDeployFtp(option: vitePluginDeployFtpOption): Plugin;
-
-export { vitePluginDeployFtp as default, type vitePluginDeployFtpOption };

package/dist/index.mjs

@@ -1,435 +0,0 @@
-// src/index.ts
-import { checkbox, select } from "@inquirer/prompts";
-import archiver from "archiver";
-import { Client } from "basic-ftp";
-import chalk from "chalk";
-import dayjs from "dayjs";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import ora from "ora";
-import { normalizePath } from "vite";
-function vitePluginDeployFtp(option) {
-  const {
-    open = true,
-    uploadPath,
-    singleBack = false,
-    singleBackFiles = ["index.html"],
-    showBackFile = false,
-    maxRetries = 3,
-    retryDelay = 1e3,
-    autoUpload = false
-  } = option || {};
-  const isMultiFtp = "ftps" in option;
-  const ftpConfigs = isMultiFtp ? option.ftps : [{ ...option, name: option.name || option.alias || option.host }];
-  const defaultFtp = isMultiFtp ? option.defaultFtp : void 0;
-  if (!uploadPath || isMultiFtp && (!option.ftps || option.ftps.length === 0)) {
-    return {
-      name: "vite-plugin-deploy-ftp",
-      apply: "build",
-      enforce: "post",
-      configResolved() {
-      },
-      closeBundle: { sequential: true, order: "post", async handler() {
-      } }
-    };
-  }
-  let outDir = "dist";
-  let buildFailed = false;
-  return {
-    name: "vite-plugin-deploy-ftp",
-    apply: "build",
-    enforce: "post",
-    buildEnd(error) {
-      if (error) buildFailed = true;
-    },
-    configResolved(config) {
-      outDir = config.build?.outDir || "dist";
-    },
-    closeBundle: {
-      sequential: true,
-      order: "post",
-      async handler() {
-        if (!open || buildFailed) return;
-        try {
-          process.stdout.write("\x1B[2J\x1B[0f");
-          await deployToFtp();
-        } catch (error) {
-          console.error(chalk.red("\u274C FTP \u90E8\u7F72\u5931\u8D25:"), error instanceof Error ? error.message : error);
-          throw error;
-        }
-      }
-    }
-  };
-  async function deployToFtp() {
-    if (!autoUpload) {
-      const ftpUploadChoice = await select({
-        message: "\u662F\u5426\u4E0A\u4F20FTP",
-        choices: ["\u662F", "\u5426"],
-        default: "\u662F"
-      });
-      if (ftpUploadChoice === "\u5426") return;
-    }
-    let selectedConfigs = [];
-    if (isMultiFtp) {
-      if (defaultFtp) {
-        const defaultConfig = ftpConfigs.find((ftp) => ftp.name === defaultFtp);
-        if (defaultConfig) {
-          if (validateFtpConfig(defaultConfig)) {
-            console.log(chalk.blue(`\u4F7F\u7528\u9ED8\u8BA4FTP\u914D\u7F6E: ${defaultFtp}`));
-            selectedConfigs = [defaultConfig];
-          } else {
-            console.log(chalk.yellow(`\u26A0\uFE0F \u9ED8\u8BA4FTP\u914D\u7F6E "${defaultFtp}" \u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\uFF0C\u5C06\u8FDB\u884C\u624B\u52A8\u9009\u62E9`));
-          }
-        }
-      }
-      if (selectedConfigs.length === 0) {
-        const validConfigs = ftpConfigs.filter(validateFtpConfig);
-        const invalidConfigs = ftpConfigs.filter((config) => !validateFtpConfig(config));
-        if (invalidConfigs.length > 0) {
-          console.log(chalk.yellow("\n \u4EE5\u4E0BFTP\u914D\u7F6E\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\uFF0C\u5DF2\u4ECE\u9009\u62E9\u5217\u8868\u4E2D\u6392\u9664:"));
-          invalidConfigs.forEach((config) => {
-            const missing = [];
-            if (!config.host) missing.push("host");
-            if (!config.user) missing.push("user");
-            if (!config.password) missing.push("password");
-            console.log(chalk.yellow(`  - ${config.name || "\u672A\u547D\u540D"}: \u7F3A\u5C11 ${missing.join(", ")}`));
-          });
-          console.log();
-        }
-        if (validConfigs.length === 0) {
-          console.error(chalk.red("\u274C \u6CA1\u6709\u53EF\u7528\u7684\u6709\u6548FTP\u914D\u7F6E"));
-          return;
-        }
-        const choices = validConfigs.map((ftp) => ({
-          name: ftp.name,
-          value: ftp
-        }));
-        selectedConfigs = await checkbox({
-          message: "\u9009\u62E9\u8981\u4E0A\u4F20\u7684FTP\u670D\u52A1\u5668\uFF08\u53EF\u591A\u9009\uFF09",
-          choices,
-          required: true
-        });
-      }
-    } else {
-      const singleConfig = ftpConfigs[0];
-      if (validateFtpConfig(singleConfig)) {
-        selectedConfigs = [{ ...singleConfig, name: singleConfig.name || singleConfig.host }];
-      } else {
-        const missing = [];
-        if (!singleConfig.host) missing.push("host");
-        if (!singleConfig.user) missing.push("user");
-        if (!singleConfig.password) missing.push("password");
-        console.error(chalk.red(`\u274C FTP\u914D\u7F6E\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: ${missing.join(", ")}`));
-        return;
-      }
-    }
-    for (const ftpConfig of selectedConfigs) {
-      const { host, port = 21, user, password, alias = "", name } = ftpConfig;
-      if (!host || !user || !password) {
-        console.error(chalk.red(`\u274C FTP\u914D\u7F6E "${name || host || "\u672A\u77E5"}" \u7F3A\u5C11\u5FC5\u9700\u53C2\u6570:`));
-        if (!host) console.error(chalk.red("  - \u7F3A\u5C11 host"));
-        if (!user) console.error(chalk.red("  - \u7F3A\u5C11 user"));
-        if (!password) console.error(chalk.red("  - \u7F3A\u5C11 password"));
-        continue;
-      }
-      const { protocol, baseUrl } = parseAlias(alias);
-      const displayName = name || host;
-      const allFiles = getAllFiles(outDir);
-      const totalFiles = allFiles.length;
-      console.log(chalk.bold(`
-\u{1F680} FTP \u90E8\u7F72\u5F00\u59CB`));
-      console.log();
-      console.log(`Host:     ${chalk.blue(host)}`);
-      console.log(`User:     ${chalk.blue(user)}`);
-      console.log(`Source:   ${chalk.blue(outDir)}`);
-      console.log(`Target:   ${chalk.blue(uploadPath)}`);
-      console.log(`Files:    ${chalk.blue(totalFiles)}`);
-      console.log();
-      const client = new Client();
-      let uploadSpinner;
-      const startTime = Date.now();
-      try {
-        uploadSpinner = ora(`\u8FDE\u63A5\u5230 ${displayName} \u4E2D...`).start();
-        await connectWithRetry(client, { host, port, user, password }, maxRetries, retryDelay);
-        uploadSpinner.color = "green";
-        uploadSpinner.text = "\u8FDE\u63A5\u6210\u529F";
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const fileList = await client.list(uploadPath);
-        uploadSpinner.succeed("\u8FDE\u63A5\u6210\u529F!");
-        const startDir = await client.pwd();
-        if (fileList.length) {
-          if (singleBack) {
-            await createSingleBackup(client, uploadPath, protocol, baseUrl, singleBackFiles, showBackFile);
-          } else {
-            const isBackFiles = await select({
-              message: `\u662F\u5426\u5907\u4EFD ${displayName} \u7684\u8FDC\u7A0B\u6587\u4EF6`,
-              choices: ["\u5426", "\u662F"],
-              default: "\u5426"
-            });
-            if (isBackFiles === "\u662F") {
-              await createBackupFile(client, uploadPath, protocol, baseUrl, showBackFile);
-            }
-          }
-        }
-        const progressSpinner = ora("\u51C6\u5907\u4E0A\u4F20...").start();
-        let uploadedCount = 0;
-        const groups = {};
-        for (const file of allFiles) {
-          const dir = path.dirname(file);
-          if (!groups[dir]) groups[dir] = [];
-          groups[dir].push(path.basename(file));
-        }
-        for (const relDir of Object.keys(groups)) {
-          await client.cd(startDir);
-          const remoteDir = normalizePath(path.join(uploadPath, relDir));
-          await client.ensureDir(remoteDir);
-          for (const fileName of groups[relDir]) {
-            const currentFile = path.join(relDir, fileName);
-            const displayPath = normalizePath(currentFile);
-            progressSpinner.text = `\u6B63\u5728\u4E0A\u4F20: ${chalk.dim(displayPath)}
-${formatProgressBar(uploadedCount, totalFiles)}`;
-            const localFile = path.join(outDir, relDir, fileName);
-            await client.uploadFrom(localFile, fileName);
-            uploadedCount++;
-          }
-        }
-        progressSpinner.succeed("\u6240\u6709\u6587\u4EF6\u4E0A\u4F20\u5B8C\u6210!");
-        console.log(chalk.green(formatProgressBar(totalFiles, totalFiles)));
-        process.stdout.write("\x1B[2J\x1B[0f");
-        console.log(chalk.gray("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
-        const duration = ((Date.now() - startTime) / 1e3).toFixed(2);
-        console.log(`\u{1F389} \u90E8\u7F72\u6210\u529F!`);
-        console.log();
-        console.log(`\u7EDF\u8BA1:`);
-        console.log(` \u2714 \u6210\u529F: ${chalk.green(totalFiles)}`);
-        console.log(` \u23F1 \u8017\u65F6: ${chalk.green(duration + "s")}`);
-        console.log();
-        if (baseUrl) {
-          console.log(`\u8BBF\u95EE\u5730\u5740: ${chalk.green(buildUrl(protocol, baseUrl, uploadPath))}`);
-          console.log();
-        }
-      } catch (error) {
-        if (uploadSpinner) {
-          uploadSpinner.fail(`\u274C \u4E0A\u4F20\u5230 ${displayName} \u5931\u8D25`);
-        }
-        console.error(chalk.red(`\u274C \u4E0A\u4F20\u5230 ${displayName} \u5931\u8D25:`), error instanceof Error ? error.message : error);
-        throw error;
-      } finally {
-        client.close();
-      }
-    }
-  }
-}
-function getAllFiles(dirPath, arrayOfFiles = [], relativePath = "") {
-  const files = fs.readdirSync(dirPath);
-  files.forEach(function(file) {
-    const fullPath = path.join(dirPath, file);
-    const relPath = path.join(relativePath, file);
-    if (fs.statSync(fullPath).isDirectory()) {
-      getAllFiles(fullPath, arrayOfFiles, relPath);
-    } else {
-      arrayOfFiles.push(relPath);
-    }
-  });
-  return arrayOfFiles;
-}
-function formatProgressBar(current, total, width = 30) {
-  const percentage = Math.round(current / total * 100);
-  const filled = Math.round(width * current / total);
-  const empty = width - filled;
-  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
-  return `${bar} ${percentage}% (${current}/${total})`;
-}
-function validateFtpConfig(config) {
-  return !!(config.host && config.user && config.password);
-}
-function parseAlias(alias = "") {
-  const [protocol = "", baseUrl = ""] = alias.split("://");
-  return {
-    protocol: protocol ? `${protocol}://` : "",
-    baseUrl: baseUrl || ""
-  };
-}
-function buildUrl(protocol, baseUrl, path2) {
-  return protocol + normalizePath(baseUrl + path2);
-}
-async function connectWithRetry(client, config, maxRetries, retryDelay) {
-  let lastError;
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      client.ftp.verbose = false;
-      await client.access({
-        ...config,
-        secure: true,
-        secureOptions: { rejectUnauthorized: false, timeout: 6e4 }
-      });
-      return;
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      if (attempt < maxRetries) {
-        console.log(chalk.yellow(`\u26A0\uFE0F \u8FDE\u63A5\u5931\u8D25\uFF0C${retryDelay}ms \u540E\u91CD\u8BD5 (${attempt}/${maxRetries})`));
-        await new Promise((resolve) => setTimeout(resolve, retryDelay));
-      }
-    }
-  }
-  throw new Error(`\u274C FTP \u8FDE\u63A5\u5931\u8D25\uFF0C\u5DF2\u91CD\u8BD5 ${maxRetries} \u6B21: ${lastError?.message}`);
-}
-function createTempDir(basePath) {
-  const tempBaseDir = os.tmpdir();
-  const tempPath = path.join(tempBaseDir, "vite-plugin-deploy-ftp", basePath);
-  if (!fs.existsSync(tempPath)) {
-    fs.mkdirSync(tempPath, { recursive: true });
-  }
-  return {
-    path: tempPath,
-    cleanup: () => {
-      try {
-        if (fs.existsSync(tempPath)) {
-          fs.rmSync(tempPath, { recursive: true, force: true });
-        }
-      } catch (error) {
-        console.warn(chalk.yellow(`\u26A0\uFE0F \u6E05\u7406\u4E34\u65F6\u76EE\u5F55\u5931\u8D25: ${tempPath}`), error);
-      }
-    }
-  };
-}
-async function createBackupFile(client, dir, protocol, baseUrl, showBackFile = false) {
-  const backupSpinner = ora(`\u521B\u5EFA\u5907\u4EFD\u6587\u4EF6\u4E2D ${chalk.yellow(`==> ${buildUrl(protocol, baseUrl, dir)}`)}`).start();
-  const fileName = `backup_${dayjs().format("YYYYMMDD_HHmmss")}.zip`;
-  const tempDir = createTempDir("backup-zip");
-  const zipFilePath = path.join(os.tmpdir(), "vite-plugin-deploy-ftp", fileName);
-  try {
-    const zipDir = path.dirname(zipFilePath);
-    if (!fs.existsSync(zipDir)) {
-      fs.mkdirSync(zipDir, { recursive: true });
-    }
-    const remoteFiles = await client.list(dir);
-    const filteredFiles = remoteFiles.filter((file) => !file.name.startsWith("backup_") || !file.name.endsWith(".zip"));
-    if (showBackFile) {
-      console.log(chalk.cyan(`
-\u5F00\u59CB\u5907\u4EFD\u8FDC\u7A0B\u6587\u4EF6\uFF0C\u5171 ${filteredFiles.length} \u4E2A\u6587\u4EF6:`));
-      filteredFiles.forEach((file) => {
-        console.log(chalk.gray(`  - ${file.name} (${file.size} bytes)`));
-      });
-    }
-    for (const file of filteredFiles) {
-      if (file.type === 1) {
-        await client.downloadTo(path.join(tempDir.path, file.name), normalizePath(`${dir}/${file.name}`));
-      }
-    }
-    backupSpinner.text = `\u4E0B\u8F7D\u8FDC\u7A0B\u6587\u4EF6\u6210\u529F ${chalk.yellow(`==> ${buildUrl(protocol, baseUrl, dir)}`)}`;
-    await createZipFile(tempDir.path, zipFilePath);
-    backupSpinner.text = `\u538B\u7F29\u5B8C\u6210, \u51C6\u5907\u4E0A\u4F20 ${chalk.yellow(
-      `==> ${buildUrl(protocol, baseUrl, dir + "/" + fileName)}`
-    )}`;
-    await client.uploadFrom(zipFilePath, normalizePath(`${dir}/${fileName}`));
-    const backupUrl = buildUrl(protocol, baseUrl, `${dir}/${fileName}`);
-    backupSpinner.succeed("\u5907\u4EFD\u5B8C\u6210");
-    console.log(chalk.cyan("\n\u5907\u4EFD\u6587\u4EF6:"));
-    console.log(chalk.green(`${backupUrl}`));
-    console.log();
-  } catch (error) {
-    backupSpinner.fail("\u5907\u4EFD\u5931\u8D25");
-    throw error;
-  } finally {
-    tempDir.cleanup();
-    try {
-      if (fs.existsSync(zipFilePath)) {
-        fs.rmSync(zipFilePath);
-      }
-    } catch (error) {
-      console.warn(chalk.yellow("\u26A0\uFE0F \u6E05\u7406zip\u6587\u4EF6\u5931\u8D25"), error);
-    }
-  }
-}
-async function createZipFile(sourceDir, outputPath) {
-  return new Promise((resolve, reject) => {
-    const output = fs.createWriteStream(outputPath);
-    const archive = archiver("zip", {
-      zlib: { level: 9 }
-    });
-    output.on("close", () => {
-      resolve();
-    });
-    archive.on("error", (err) => {
-      reject(err);
-    });
-    archive.pipe(output);
-    archive.directory(sourceDir, false);
-    archive.finalize();
-  });
-}
-async function createSingleBackup(client, dir, protocol, baseUrl, singleBackFiles, showBackFile = false) {
-  const timestamp = dayjs().format("YYYYMMDD_HHmmss");
-  const backupSpinner = ora(`\u5907\u4EFD\u6307\u5B9A\u6587\u4EF6\u4E2D ${chalk.yellow(`==> ${buildUrl(protocol, baseUrl, dir)}`)}`).start();
-  const tempDir = createTempDir("single-backup");
-  let backupProgressSpinner;
-  try {
-    const remoteFiles = await client.list(dir);
-    const backupTasks = singleBackFiles.map((fileName) => {
-      const remoteFile = remoteFiles.find((f) => f.name === fileName);
-      return remoteFile ? { fileName, exists: true } : { fileName, exists: false };
-    }).filter((task) => task.exists);
-    if (backupTasks.length === 0) {
-      backupSpinner.warn("\u672A\u627E\u5230\u9700\u8981\u5907\u4EFD\u7684\u6587\u4EF6");
-      return;
-    }
-    backupSpinner.stop();
-    if (showBackFile) {
-      console.log(chalk.cyan(`
-\u5F00\u59CB\u5355\u6587\u4EF6\u5907\u4EFD\uFF0C\u5171 ${backupTasks.length} \u4E2A\u6587\u4EF6:`));
-      backupTasks.forEach((task) => {
-        console.log(chalk.gray(`  - ${task.fileName}`));
-      });
-    }
-    backupProgressSpinner = ora("\u6B63\u5728\u5907\u4EFD\u6587\u4EF6...").start();
-    const concurrencyLimit = 3;
-    let backedUpCount = 0;
-    const backedUpFiles = [];
-    for (let i = 0; i < backupTasks.length; i += concurrencyLimit) {
-      const batch = backupTasks.slice(i, i + concurrencyLimit);
-      const promises = batch.map(async ({ fileName }) => {
-        try {
-          const localTempPath = path.join(tempDir.path, fileName);
-          const [name, ext] = fileName.split(".");
-          const suffix = ext ? `.${ext}` : "";
-          const backupFileName = `${name}.${timestamp}${suffix}`;
-          const backupRemotePath = normalizePath(`${dir}/${backupFileName}`);
-          await client.downloadTo(localTempPath, normalizePath(`${dir}/${fileName}`));
-          await client.uploadFrom(localTempPath, backupRemotePath);
-          const backupUrl = buildUrl(protocol, baseUrl, backupRemotePath);
-          backedUpFiles.push(backupUrl);
-          return true;
-        } catch (error) {
-          console.warn(chalk.yellow(`\u5907\u4EFD\u6587\u4EF6 ${fileName} \u5931\u8D25:`), error instanceof Error ? error.message : error);
-          return false;
-        }
-      });
-      const results = await Promise.all(promises);
-      backedUpCount += results.filter(Boolean).length;
-    }
-    if (backedUpCount > 0) {
-      backupProgressSpinner.succeed("\u5907\u4EFD\u5B8C\u6210");
-      console.log(chalk.cyan("\n\u5907\u4EFD\u6587\u4EF6:"));
-      backedUpFiles.forEach((url) => {
-        console.log(chalk.green(`\u{1F517}  ${url}`));
-      });
-      console.log();
-    } else {
-      backupProgressSpinner.fail("\u6240\u6709\u6587\u4EF6\u5907\u4EFD\u5931\u8D25");
-    }
-  } catch (error) {
-    if (backupProgressSpinner) {
-      backupProgressSpinner.fail("\u5907\u4EFD\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF");
-    } else {
-      backupSpinner.fail("\u5907\u4EFD\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF");
-    }
-    throw error;
-  } finally {
-    tempDir.cleanup();
-  }
-}
-export {
-  vitePluginDeployFtp as default
-};