@file-ud.js/plugins 0.1.0

package/dist/index.js

@@ -0,0 +1,781 @@
+'use strict';
+
+var core = require('@file-ud.js/core');
+
+// src/uploader/compress/compress-image-plugin.ts
+var BasePlugin = class {
+  constructor() {
+    /** 插件版本 */
+    this.version = "1.0.0";
+    /** 插件优先级 */
+    this.priority = 0;
+    /** 是否关键插件 */
+    this.critical = false;
+    /** 插件描述 */
+    this.desc = "";
+  }
+  /**
+   * 安装插件 - 统一日志输出
+   */
+  install(transfer) {
+    console.log(`${this.name} \u2705 \u63D2\u4EF6\u5DF2\u5B89\u88C5`);
+  }
+  /**
+   * 创建基础错误对象
+   * @param file - 当前文件
+   * @param uploader - 上传器实例
+   * @returns 基础错误对象
+   */
+  createBaseError(file, uploader) {
+    return new core.FileUDError(
+      core.ErrorCode.UNKNOWN,
+      "",
+      {
+        uploader,
+        plugin: this.name,
+        fileName: file.fileName,
+        fileSize: file.File.size,
+        fileType: file.File.type
+      }
+    );
+  }
+  /**
+   * 抛出验证错误
+   * @param error - 错误对象
+   * @returns Promise.reject
+   */
+  throwError(error) {
+    return Promise.reject(error);
+  }
+  /**
+   * 销毁插件
+   */
+  destroy() {
+    console.log(`${this.name} \u{1F512} \u63D2\u4EF6\u5DF2\u9500\u6BC1`);
+  }
+};
+
+// src/uploader/compress/compress-image-plugin.ts
+var CompressImagePlugin = class extends BasePlugin {
+  constructor(options = {}) {
+    super();
+    this.name = "compress-image-plugin";
+    this.priority = 10;
+    this.desc = "\u56FE\u7247\u538B\u7F29\u63D2\u4EF6";
+    this.defaultOptions = {
+      quality: 0.8,
+      maxWidth: 1920,
+      maxHeight: 1080,
+      format: "jpeg",
+      showInfo: true,
+      onCompressStart: function(file) {
+        throw new Error("Function not implemented.");
+      },
+      onCompressComplete: function(file, compressedFile) {
+        throw new Error("Function not implemented.");
+      }
+    };
+    this.options = { ...this.defaultOptions, ...options };
+  }
+  async onFileSelect(uploadFile, context) {
+    if (!uploadFile.File.type.startsWith("image/")) {
+      return uploadFile;
+    }
+    const originalSize = uploadFile.File.size;
+    try {
+      this.options.onCompressStart?.(uploadFile);
+      const compressedFile = await this.compressImage(uploadFile.File);
+      const compressedSize = compressedFile.size;
+      const ratio = ((originalSize - compressedSize) / originalSize * 100).toFixed(1);
+      if (this.options.showInfo) {
+        console.log(
+          `\u{1F4F8} \u538B\u7F29\u5B8C\u6210: ${uploadFile.fileName} | ${core.formatFileSize(originalSize)} \u2192 ${core.formatFileSize(compressedSize)} (\u51CF\u5C11 ${ratio}%)`
+        );
+      }
+      uploadFile.proxy.File = compressedFile;
+      this.options.onCompressComplete?.(uploadFile, compressedFile);
+      uploadFile.proxy.formatSize = core.formatFileSize(compressedSize);
+      return uploadFile;
+    } catch (error) {
+      console.error(`\u538B\u7F29\u5931\u8D25: ${uploadFile.fileName}`, error);
+      return uploadFile;
+    }
+  }
+  compressImage(file) {
+    return new Promise((resolve, reject) => {
+      const img = new Image();
+      const url = URL.createObjectURL(file);
+      img.onload = () => {
+        URL.revokeObjectURL(url);
+        let { width, height } = img;
+        if (width > this.options.maxWidth) {
+          height = Math.floor(height * (this.options.maxWidth / width));
+          width = this.options.maxWidth;
+        }
+        if (height > this.options.maxHeight) {
+          width = Math.floor(width * (this.options.maxHeight / height));
+          height = this.options.maxHeight;
+        }
+        const canvas = document.createElement("canvas");
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+          reject(new Error("\u65E0\u6CD5\u521B\u5EFA Canvas \u4E0A\u4E0B\u6587"));
+          return;
+        }
+        ctx.drawImage(img, 0, 0, width, height);
+        canvas.toBlob(
+          (blob) => {
+            if (blob) {
+              const compressedFile = new File(
+                [blob],
+                file.name.replace(/\.\w+$/, `.${this.options.format}`),
+                { type: `image/${this.options.format}` }
+              );
+              resolve(compressedFile);
+            } else {
+              reject(new Error("\u538B\u7F29\u5931\u8D25"));
+            }
+          },
+          `image/${this.options.format}`,
+          this.options.quality
+        );
+      };
+      img.onerror = () => reject(new Error("\u56FE\u7247\u52A0\u8F7D\u5931\u8D25"));
+      img.src = url;
+    });
+  }
+};
+var WatermarkPlugin = class extends BasePlugin {
+  constructor(options = {}) {
+    super();
+    this.name = "watermark-plugin";
+    this.priority = 20;
+    this.desc = "\u6C34\u5370\u63D2\u4EF6\uFF08\u652F\u6301\u6587\u5B57/\u56FE\u7247\u6C34\u5370\uFF09";
+    this.defaultOptions = {
+      text: "\xA9 FileUD",
+      imageUrl: "",
+      position: "bottom-right",
+      opacity: 0.6,
+      fontSize: 24,
+      color: "#ffffff",
+      padding: 20,
+      imageWidth: 100,
+      imageHeight: 100
+    };
+    this.options = { ...this.defaultOptions, ...options };
+  }
+  async onFileSelect(file, context) {
+    if (!file.File.type.startsWith("image/")) {
+      return file;
+    }
+    try {
+      const watermarkedFile = await this.addWatermark(file.File);
+      file.proxy.File = watermarkedFile;
+      file.proxy.formatSize = core.formatFileSize(watermarkedFile.size);
+      console.log(`\u{1F4A7} \u6C34\u5370\u5DF2\u6DFB\u52A0: ${file.fileName}`);
+      return file;
+    } catch (error) {
+      console.error(`\u6C34\u5370\u6DFB\u52A0\u5931\u8D25: ${file.fileName}`, error);
+      return file;
+    }
+  }
+  addWatermark(file) {
+    return new Promise((resolve, reject) => {
+      const img = new Image();
+      const url = URL.createObjectURL(file);
+      img.onload = () => {
+        URL.revokeObjectURL(url);
+        const canvas = document.createElement("canvas");
+        canvas.width = img.width;
+        canvas.height = img.height;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+          reject(new Error("\u65E0\u6CD5\u521B\u5EFA Canvas \u4E0A\u4E0B\u6587"));
+          return;
+        }
+        ctx.drawImage(img, 0, 0);
+        ctx.globalAlpha = this.options.opacity;
+        if (this.options.imageUrl) {
+          this.addImageWatermark(ctx, canvas, resolve, reject, file);
+        } else if (this.options.text) {
+          this.addTextWatermark(ctx, canvas, resolve, reject, file);
+        }
+      };
+      img.onerror = () => reject(new Error("\u56FE\u7247\u52A0\u8F7D\u5931\u8D25"));
+      img.src = url;
+    });
+  }
+  /**
+   * 添加文字水印
+   */
+  addTextWatermark(ctx, canvas, resolve, reject, originalFile) {
+    ctx.font = `${this.options.fontSize}px Arial`;
+    ctx.fillStyle = this.options.color;
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    const text = this.options.text;
+    const textWidth = ctx.measureText(text).width;
+    const padding = this.options.padding;
+    const { x, y } = this.calculatePosition(
+      ctx,
+      canvas,
+      textWidth,
+      this.options.fontSize,
+      padding
+    );
+    ctx.fillText(text, x, y);
+    canvas.toBlob((blob) => {
+      if (blob) {
+        const watermarkedFile = new File([blob], originalFile.name, {
+          type: originalFile.type
+        });
+        resolve(watermarkedFile);
+      } else {
+        reject(new Error("\u6C34\u5370\u6DFB\u52A0\u5931\u8D25"));
+      }
+    }, originalFile.type);
+  }
+  /**
+   * 添加图片水印
+   */
+  addImageWatermark(ctx, canvas, resolve, reject, originalFile) {
+    const watermarkImg = new Image();
+    watermarkImg.crossOrigin = "Anonymous";
+    watermarkImg.onload = () => {
+      let drawWidth = this.options.imageWidth;
+      let drawHeight = this.options.imageHeight;
+      if (!drawWidth && !drawHeight) {
+        drawWidth = watermarkImg.width;
+        drawHeight = watermarkImg.height;
+      } else if (drawWidth && !drawHeight) {
+        drawHeight = watermarkImg.height / watermarkImg.width * drawWidth;
+      } else if (!drawWidth && drawHeight) {
+        drawWidth = watermarkImg.width / watermarkImg.height * drawHeight;
+      }
+      const padding = this.options.padding;
+      const { x, y } = this.calculatePosition(
+        ctx,
+        canvas,
+        drawWidth,
+        drawHeight,
+        padding
+      );
+      ctx.drawImage(watermarkImg, x, y, drawWidth, drawHeight);
+      canvas.toBlob((blob) => {
+        if (blob) {
+          const watermarkedFile = new File([blob], originalFile.name, {
+            type: originalFile.type
+          });
+          resolve(watermarkedFile);
+        } else {
+          reject(new Error("\u6C34\u5370\u6DFB\u52A0\u5931\u8D25"));
+        }
+      }, originalFile.type);
+    };
+    watermarkImg.onerror = () => {
+      reject(new Error("\u6C34\u5370\u56FE\u7247\u52A0\u8F7D\u5931\u8D25"));
+    };
+    watermarkImg.src = this.options.imageUrl;
+  }
+  /**
+   * 计算水印位置
+   */
+  calculatePosition(ctx, canvas, width, height, padding) {
+    const pad = padding ?? this.options.padding;
+    let x, y;
+    switch (this.options.position) {
+      case "top-left":
+        x = pad;
+        y = pad;
+        break;
+      case "top-right":
+        x = canvas.width - width - pad;
+        y = pad;
+        break;
+      case "bottom-left":
+        x = pad;
+        y = canvas.height - height - pad;
+        break;
+      case "bottom-right":
+        x = canvas.width - width - pad;
+        y = canvas.height - height - pad;
+        break;
+      default:
+        x = (canvas.width - width) / 2;
+        y = (canvas.height - height) / 2;
+    }
+    return { x, y };
+  }
+};
+var FileValidatorPlugin = class extends BasePlugin {
+  constructor(options = {}) {
+    super();
+    this.name = "file-validator-plugin";
+    this.priority = 0;
+    // 最先执行
+    this.critical = true;
+    this.desc = "\u57FA\u7840\u9A8C\u8BC1\u63D2\u4EF6\uFF08\u5927\u5C0F\u3001\u7C7B\u578B\u3001\u6570\u91CF\uFF09";
+    this.defaultOptions = {
+      maxSize: Infinity,
+      minSize: 0,
+      accept: [],
+      allowEmpty: false,
+      customValidate: async () => true,
+      messages: {}
+    };
+    this.options = { ...this.defaultOptions, ...options };
+  }
+  async created(uploader) {
+    uploader.inputHTML?.setAttribute("accept", this.options.accept.join(","));
+  }
+  async onFileSelect(file, context) {
+    const uploader = context.transfer;
+    const baseError = this.createBaseError(file, uploader);
+    if (!this.options.allowEmpty && file.File.size === 0) {
+      const msg = this.options.messages.empty?.() || `\u6587\u4EF6 ${file.fileName} \u662F\u7A7A\u6587\u4EF6`;
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.FILE_EMPTY).setMessage(msg)
+      );
+    }
+    if (file.File.size < this.options.minSize) {
+      const msg = this.options.messages.minSize?.(this.options.minSize, file.File.size) || `\u6587\u4EF6 ${file.fileName} \u592A\u5C0F\uFF0C\u6700\u5C0F ${core.formatFileSize(this.options.minSize)}`;
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.FILE_TOO_SMALL).setMessage(msg).setContext({
+          minSize: this.options.minSize,
+          currentSize: file.File.size
+        })
+      );
+    }
+    if (file.File.size > this.options.maxSize) {
+      const msg = this.options.messages.maxSize?.(this.options.maxSize, file.File.size) || `\u6587\u4EF6 ${file.fileName} \u592A\u5927\uFF0C\u6700\u5927 ${core.formatFileSize(this.options.maxSize)}`;
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.FILE_TOO_LARGE).setMessage(msg).setContext({
+          maxSize: this.options.maxSize,
+          currentSize: file.File.size
+        })
+      );
+    }
+    if (!core.validator.type(this.options.accept, file)) {
+      const msg = this.options.messages.accept?.(this.options.accept, file.fileName) || `\u6587\u4EF6 ${file.fileName} \u7C7B\u578B\u4E0D\u652F\u6301\uFF0C\u5141\u8BB8\uFF1A${this.options.accept.join(", ")}`;
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.INVALID_TYPE).setMessage(msg)
+      );
+    }
+    try {
+      const customResult = await this.options.customValidate(
+        file.File,
+        core.FileUDError
+      );
+      if (!customResult) {
+        const msg = this.options.messages.custom?.(file.fileName) || `\u6587\u4EF6 ${file.fileName} \u9A8C\u8BC1\u5931\u8D25`;
+        return this.throwError(
+          baseError.setCode(core.ErrorCode.FILE_CORRUPTED).setMessage(msg)
+        );
+      }
+    } catch (error) {
+      console.log("\u{1F680} ~ FileValidatorPlugin ~ onFileSelect ~ error:", error);
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.PLUGIN_ERROR).setMessage("\u6587\u4EF6\u9A8C\u8BC1\u8FC7\u7A0B\u51FA\u9519").setContext({
+          originalError: error
+        })
+      );
+    }
+    return file;
+  }
+};
+var ImageValidatorPlugin = class extends BasePlugin {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.name = "image-validator-plugin";
+    this.priority = 0;
+    this.desc = "\u56FE\u7247\u9A8C\u8BC1\u63D2\u4EF6\uFF08\u5C3A\u5BF8\u3001\u6BD4\u4F8B\u3001\u5206\u8FA8\u7387\uFF09";
+  }
+  async onFileSelect(file, context) {
+    if (!file.File.type.startsWith("image/")) {
+      return file;
+    }
+    const dimensions = await this.getImageDimensions(file.File);
+    const baseError = this.createBaseError(file, context.transfer);
+    if (this.options.exactWidth && dimensions.width !== this.options.exactWidth) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.IMAGE_WIDTH_INVALID).setMessage(
+          `\u5BBD\u5EA6\u5FC5\u987B\u4E3A ${this.options.exactWidth}px\uFF0C\u5F53\u524D ${dimensions.width}px`
+        ).setContext({ width: dimensions.width })
+      );
+    }
+    if (this.options.minWidth && dimensions.width < this.options.minWidth) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.IMAGE_WIDTH_INVALID).setMessage(
+          `\u5BBD\u5EA6\u4E0D\u80FD\u5C0F\u4E8E ${this.options.minWidth}px\uFF0C\u5F53\u524D ${dimensions.width}px`
+        ).setContext({ width: dimensions.width })
+      );
+    }
+    if (this.options.maxWidth && dimensions.width > this.options.maxWidth) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.IMAGE_WIDTH_INVALID).setMessage(
+          `\u5BBD\u5EA6\u4E0D\u80FD\u5927\u4E8E ${this.options.maxWidth}px\uFF0C\u5F53\u524D ${dimensions.width}px`
+        ).setContext({ width: dimensions.width })
+      );
+    }
+    if (this.options.exactHeight && dimensions.height !== this.options.exactHeight) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.IMAGE_HEIGHT_INVALID).setMessage(
+          `\u9AD8\u5EA6\u5FC5\u987B\u4E3A ${this.options.exactHeight}px\uFF0C\u5F53\u524D ${dimensions.height}px`
+        ).setContext({ height: dimensions.height })
+      );
+    }
+    if (this.options.minHeight && dimensions.height < this.options.minHeight) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.IMAGE_HEIGHT_INVALID).setMessage(
+          `\u9AD8\u5EA6\u4E0D\u80FD\u5C0F\u4E8E ${this.options.minHeight}px\uFF0C\u5F53\u524D ${dimensions.height}px`
+        ).setContext({ height: dimensions.height })
+      );
+    }
+    if (this.options.maxHeight && dimensions.height > this.options.maxHeight) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.IMAGE_HEIGHT_INVALID).setMessage(
+          `\u9AD8\u5EA6\u4E0D\u80FD\u5927\u4E8E ${this.options.maxHeight}px\uFF0C\u5F53\u524D ${dimensions.height}px`
+        ).setContext({ height: dimensions.height })
+      );
+    }
+    if (this.options.square && dimensions.width !== dimensions.height) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.IMAGE_NOT_SQUARE).setMessage(
+          `\u56FE\u7247\u5FC5\u987B\u662F\u6B63\u65B9\u5F62\uFF0C\u5F53\u524D ${dimensions.width}x${dimensions.height}`
+        ).setContext({
+          width: dimensions.width,
+          height: dimensions.height
+        })
+      );
+    }
+    const aspectRatio = dimensions.width / dimensions.height;
+    if (this.options.minAspectRatio && aspectRatio < this.options.minAspectRatio) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.IMAGE_ASPECT_RATIO_INVALID).setMessage(
+          `\u5BBD\u9AD8\u6BD4\u4E0D\u80FD\u5C0F\u4E8E ${this.options.minAspectRatio}\uFF0C\u5F53\u524D ${aspectRatio.toFixed(2)}`
+        ).setContext({ aspectRatio })
+      );
+    }
+    if (this.options.maxAspectRatio && aspectRatio > this.options.maxAspectRatio) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.IMAGE_ASPECT_RATIO_INVALID).setMessage(
+          `\u5BBD\u9AD8\u6BD4\u4E0D\u80FD\u5927\u4E8E ${this.options.maxAspectRatio}\uFF0C\u5F53\u524D ${aspectRatio.toFixed(2)}`
+        ).setContext({ aspectRatio })
+      );
+    }
+    if (this.options.aspectRatios?.length) {
+      const isValid = this.options.aspectRatios.some(
+        (ratio) => Math.abs(aspectRatio - ratio) < 0.01
+      );
+      if (!isValid) {
+        return this.throwError(
+          baseError.setCode(core.ErrorCode.IMAGE_ASPECT_RATIO_INVALID).setMessage(
+            `\u5BBD\u9AD8\u6BD4\u5FC5\u987B\u4E3A ${this.options.aspectRatios.join(", ")}\uFF0C\u5F53\u524D ${aspectRatio.toFixed(2)}`
+          ).setContext({ aspectRatio })
+        );
+      }
+    }
+    const resolution = dimensions.width * dimensions.height;
+    if (this.options.minResolution && resolution < this.options.minResolution) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.IMAGE_RESOLUTION_INVALID).setMessage(
+          `\u5206\u8FA8\u7387\u4E0D\u80FD\u5C0F\u4E8E ${this.options.minResolution}px\xB2\uFF0C\u5F53\u524D ${resolution}px\xB2`
+        ).setContext({ resolution })
+      );
+    }
+    if (this.options.maxResolution && resolution > this.options.maxResolution) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.IMAGE_RESOLUTION_INVALID).setMessage(
+          `\u5206\u8FA8\u7387\u4E0D\u80FD\u5927\u4E8E ${this.options.maxResolution}px\xB2\uFF0C\u5F53\u524D ${resolution}px\xB2`
+        ).setContext({ resolution })
+      );
+    }
+    if (this.options.allowAnimated === false && file.File.type === "image/gif") {
+      const isAnimated = await this.isAnimatedGif(file.File);
+      if (isAnimated) {
+        return this.throwError(
+          baseError.setCode(core.ErrorCode.IMAGE_ANIMATED).setMessage("\u4E0D\u652F\u6301\u52A8\u6001\u56FE\u7247")
+        );
+      }
+    }
+    file.metadata = {
+      ...file.metadata,
+      width: dimensions.width,
+      height: dimensions.height,
+      aspectRatio,
+      resolution
+    };
+    return file;
+  }
+  /**
+   * 获取图片尺寸
+   */
+  async getImageDimensions(file) {
+    return new Promise((resolve, reject) => {
+      const img = new Image();
+      img.onload = () => resolve({ width: img.width, height: img.height });
+      img.onerror = reject;
+      img.src = URL.createObjectURL(file);
+    });
+  }
+  /**
+   * 检查 GIF 是否为动态图片
+   */
+  async isAnimatedGif(file) {
+    const buffer = await file.arrayBuffer();
+    const view = new DataView(buffer);
+    if (view.getUint8(0) !== 71 || view.getUint8(1) !== 73 || view.getUint8(2) !== 70 || view.getUint8(3) !== 56) {
+      return false;
+    }
+    let frames = 0;
+    const maxFrames = 2;
+    let offset = 6;
+    while (offset < view.byteLength && frames < maxFrames) {
+      const blockId = view.getUint8(offset);
+      if (blockId === 33) {
+        offset += 2;
+        const blockSize = view.getUint8(offset);
+        offset += blockSize + 1;
+      } else if (blockId === 44) {
+        frames++;
+        offset += 10;
+      } else if (blockId === 59) {
+        break;
+      } else {
+        offset++;
+      }
+    }
+    return frames > 1;
+  }
+};
+var VideoValidatorPlugin = class extends BasePlugin {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.name = "video-validator-plugin";
+    this.version = "1.0.0";
+    this.priority = 0;
+  }
+  async onFileSelect(file, context) {
+    if (!file.File.type.startsWith("video/")) {
+      return file;
+    }
+    const metadata = await this.getVideoMetadata(file.File);
+    const baseError = this.createBaseError(file, context.transfer);
+    if (this.options.minDuration && metadata.duration < this.options.minDuration) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.VIDEO_DURATION_INVALID).setMessage(
+          `\u89C6\u9891\u65F6\u957F\u4E0D\u80FD\u5C0F\u4E8E ${this.options.minDuration}\u79D2\uFF0C\u5F53\u524D ${metadata.duration.toFixed(1)}\u79D2`
+        ).setContext({ duration: metadata.duration })
+      );
+    }
+    if (this.options.maxDuration && metadata.duration > this.options.maxDuration) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.VIDEO_DURATION_INVALID).setMessage(
+          `\u89C6\u9891\u65F6\u957F\u4E0D\u80FD\u5927\u4E8E ${this.options.maxDuration}\u79D2\uFF0C\u5F53\u524D ${metadata.duration.toFixed(1)}\u79D2`
+        ).setContext({ duration: metadata.duration })
+      );
+    }
+    if (this.options.minWidth && metadata.width < this.options.minWidth) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.VIDEO_WIDTH_INVALID).setMessage(
+          `\u89C6\u9891\u5BBD\u5EA6\u4E0D\u80FD\u5C0F\u4E8E ${this.options.minWidth}px\uFF0C\u5F53\u524D ${metadata.width}px`
+        ).setContext({ width: metadata.width })
+      );
+    }
+    if (this.options.minHeight && metadata.height < this.options.minHeight) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.VIDEO_HEIGHT_INVALID).setMessage(
+          `\u89C6\u9891\u9AD8\u5EA6\u4E0D\u80FD\u5C0F\u4E8E ${this.options.minHeight}px\uFF0C\u5F53\u524D ${metadata.height}px`
+        ).setContext({ height: metadata.height })
+      );
+    }
+    if (this.options.minBitrate && metadata.bitrate < this.options.minBitrate) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.VIDEO_BITRATE_INVALID).setMessage(
+          `\u89C6\u9891\u6BD4\u7279\u7387\u4E0D\u80FD\u5C0F\u4E8E ${this.options.minBitrate}kbps\uFF0C\u5F53\u524D ${metadata.bitrate}kbps`
+        ).setContext({ bitrate: metadata.bitrate })
+      );
+    }
+    if (this.options.maxBitrate && metadata.bitrate > this.options.maxBitrate) {
+      return this.throwError(
+        baseError.setCode(core.ErrorCode.VIDEO_BITRATE_INVALID).setMessage(
+          `\u89C6\u9891\u6BD4\u7279\u7387\u4E0D\u80FD\u5927\u4E8E ${this.options.maxBitrate}kbps\uFF0C\u5F53\u524D ${metadata.bitrate}kbps`
+        ).setContext({ bitrate: metadata.bitrate })
+      );
+    }
+    if (this.options.allowedCodecs?.length) {
+      const codecValid = this.options.allowedCodecs.some(
+        (codec) => metadata.codec?.includes(codec)
+      );
+      if (!codecValid) {
+        return this.throwError(
+          baseError.setCode(core.ErrorCode.VIDEO_CODEC_INVALID).setMessage(
+            `\u89C6\u9891\u7F16\u7801\u683C\u5F0F\u4E0D\u652F\u6301\uFF0C\u5F53\u524D ${metadata.codec || "\u672A\u77E5"}\uFF0C\u5141\u8BB8\uFF1A${this.options.allowedCodecs.join(", ")}`
+          ).setContext({ codec: metadata.codec })
+        );
+      }
+    }
+    file.metadata = { ...file.metadata, video: metadata };
+    return file;
+  }
+  /**
+   * 获取视频元数据
+   */
+  async getVideoMetadata(file) {
+    return new Promise((resolve, reject) => {
+      const video = document.createElement("video");
+      video.preload = "metadata";
+      video.onloadedmetadata = () => {
+        URL.revokeObjectURL(video.src);
+        resolve({
+          duration: video.duration,
+          width: video.videoWidth,
+          height: video.videoHeight,
+          bitrate: 0,
+          // 浏览器无法直接获取比特率，需要后端提供或估算
+          codec: video.currentSrc.split(",").pop()?.split('"')[1]
+        });
+      };
+      video.onerror = () => {
+        URL.revokeObjectURL(video.src);
+        reject(new Error("Failed to load video metadata"));
+      };
+      video.src = URL.createObjectURL(file);
+    });
+  }
+};
+
+// src/retry/smart-retry-plugin.ts
+var SmartRetryPlugin = class {
+  // 文件ID -> 重试定时器
+  constructor(config = {}) {
+    this.name = "SmartRetryPlugin";
+    this.version = "1.0.0";
+    this.desc = "\u667A\u80FD\u91CD\u8BD5\u7B56\u7565\u63D2\u4EF6\uFF0C\u540C\u65F6\u652F\u6301\u4E0A\u4F20/\u4E0B\u8F7D\uFF0C\u652F\u6301\u6307\u6570\u9000\u907F\u3001\u7EBF\u6027\u589E\u957F\u7B49\u591A\u79CD\u91CD\u8BD5\u7B56\u7565";
+    this.priority = 10;
+    this.retryCountMap = /* @__PURE__ */ new Map();
+    // 文件ID -> 重试次数
+    this.retryTimerMap = /* @__PURE__ */ new Map();
+    this.config = {
+      maxRetries: config.maxRetries ?? 3,
+      strategy: config.strategy ?? "exponential",
+      initialDelay: config.initialDelay ?? 1e3,
+      maxDelay: config.maxDelay ?? 3e4,
+      retryableErrors: config.retryableErrors ?? [],
+      showRetryNotification: config.showRetryNotification ?? true
+    };
+  }
+  /**
+   * 插件初始化
+   */
+  install(transfer, options) {
+    console.log(`\u2705 [${this.name}] \u63D2\u4EF6\u5DF2\u5B89\u88C5`, this.config);
+  }
+  /**
+   * 传输失败时触发（上传/下载通用）
+   */
+  onError(error, file, context) {
+    const fileId = file.fileId;
+    const currentRetries = this.retryCountMap.get(fileId) || 0;
+    if (currentRetries >= this.config.maxRetries) {
+      console.warn(
+        `[${this.name}] \u6587\u4EF6 ${file.fileName} \u5DF2\u8FBE\u5230\u6700\u5927\u91CD\u8BD5\u6B21\u6570 (${this.config.maxRetries})\uFF0C\u505C\u6B62\u91CD\u8BD5`
+      );
+      this.cleanup(fileId);
+      return;
+    }
+    if (!this.isRetryableError(error)) {
+      console.log(
+        `[${this.name}] \u6587\u4EF6 ${file.fileName} \u7684\u9519\u8BEF\u4E0D\u53EF\u91CD\u8BD5\uFF0C\u8DF3\u8FC7\u91CD\u8BD5`
+      );
+      return;
+    }
+    const delay = this.calculateDelay(currentRetries);
+    const timer = setTimeout(() => {
+      console.log(
+        `[${this.name}] \u6587\u4EF6 ${file.fileName} \u7B2C ${currentRetries + 1}/${this.config.maxRetries} \u6B21\u91CD\u8BD5\uFF08\u5EF6\u8FDF ${delay}ms\uFF09`
+      );
+      this.retryCountMap.set(fileId, currentRetries + 1);
+      file.retry();
+      this.retryTimerMap.delete(fileId);
+    }, delay);
+    this.retryTimerMap.set(fileId, timer);
+    if (this.config.showRetryNotification) {
+      console.info(
+        `[${this.name}] \u23F3 \u6587\u4EF6 ${file.fileName} \u5C06\u5728 ${delay}ms \u540E\u81EA\u52A8\u91CD\u8BD5...`
+      );
+    }
+  }
+  /**
+   * 传输成功时清理重试状态
+   */
+  onSuccess(response, file, context) {
+    this.cleanup(file.fileId);
+  }
+  /**
+   * 文件移除时清理重试状态
+   */
+  destroy() {
+    this.retryTimerMap.forEach((timer) => clearTimeout(timer));
+    this.retryTimerMap.clear();
+    this.retryCountMap.clear();
+    console.log(`\u{1F5D1}\uFE0F [${this.name}] \u63D2\u4EF6\u5DF2\u9500\u6BC1`);
+  }
+  /**
+   * 判断错误是否可重试
+   */
+  isRetryableError(error) {
+    if (this.config.retryableErrors.length === 0) {
+      return true;
+    }
+    const errorCode = error.code || error.message || "";
+    return this.config.retryableErrors.some(
+      (code) => errorCode.includes(code)
+    );
+  }
+  /**
+   * 计算延迟时间
+   */
+  calculateDelay(retryCount) {
+    const { strategy, initialDelay, maxDelay } = this.config;
+    let delay;
+    switch (strategy) {
+      case "fixed":
+        delay = initialDelay;
+        break;
+      case "linear":
+        delay = initialDelay * (retryCount + 1);
+        break;
+      case "exponential":
+      default:
+        delay = initialDelay * Math.pow(2, retryCount);
+        break;
+    }
+    return Math.min(delay, maxDelay);
+  }
+  /**
+   * 清理文件的重试状态
+   */
+  cleanup(fileId) {
+    const timer = this.retryTimerMap.get(fileId);
+    if (timer) {
+      clearTimeout(timer);
+      this.retryTimerMap.delete(fileId);
+    }
+    this.retryCountMap.delete(fileId);
+  }
+};
+
+exports.BasePlugin = BasePlugin;
+exports.CompressImagePlugin = CompressImagePlugin;
+exports.FileValidatorPlugin = FileValidatorPlugin;
+exports.ImageValidatorPlugin = ImageValidatorPlugin;
+exports.SmartRetryPlugin = SmartRetryPlugin;
+exports.VideoValidatorPlugin = VideoValidatorPlugin;
+exports.WatermarkPlugin = WatermarkPlugin;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map