@zhaoshijun/compress 1.1.5 → 1.2.0

package/bin/compress.js

@@ -33,6 +33,17 @@ program
   .option('--watermark-opacity <opacity>', '水印透明度 (0-1)', parseFloat)
   .option('--watermark-density <density>', '水印密度 (1-10)', parseInt)
   .option('--watermark-color <color>', '水印颜色 (hex 或 rgba)')
+  .option('--watermark-mode <mode>', '水印模式 (text/image/tiled)')
+  .option('--watermark-image <path>', '水印图片路径')
+  .option('--watermark-x <x>', '水印 X 坐标', parseInt)
+  .option('--watermark-y <y>', '水印 Y 坐标', parseInt)
+  .option('--watermark-width <width>', '水印宽度', parseInt)
+  .option('--watermark-height <height>', '水印高度', parseInt)
+  .option('--watermark-position <position>', '水印位置 (top-left/top-right/bottom-left/bottom-right/center)')
+  .option('--watermark-padding <padding>', '水印边距', parseInt)
+  .option('--watermark-angle <angle>', '水印倾斜角度', parseInt)
+  .option('--watermark-spacing-x <spacingX>', '水印水平间隔', parseInt)
+  .option('--watermark-spacing-y <spacingY>', '水印垂直间隔', parseInt)
   .action(async (options) => {
     try {
       const startTime = Date.now();
@@ -50,6 +61,17 @@ program
         if (options.watermarkOpacity !== undefined) config.watermark.opacity = options.watermarkOpacity;
         if (options.watermarkDensity !== undefined) config.watermark.density = options.watermarkDensity;
         if (options.watermarkColor) config.watermark.color = options.watermarkColor;
+        if (options.watermarkMode) config.watermark.mode = options.watermarkMode;
+        if (options.watermarkImage) config.watermark.imagePath = options.watermarkImage;
+        if (options.watermarkX !== undefined) config.watermark.x = options.watermarkX;
+        if (options.watermarkY !== undefined) config.watermark.y = options.watermarkY;
+        if (options.watermarkWidth !== undefined) config.watermark.width = options.watermarkWidth;
+        if (options.watermarkHeight !== undefined) config.watermark.height = options.watermarkHeight;
+        if (options.watermarkPosition) config.watermark.position = options.watermarkPosition;
+        if (options.watermarkPadding !== undefined) config.watermark.padding = options.watermarkPadding;
+        if (options.watermarkAngle !== undefined) config.watermark.angle = options.watermarkAngle;
+        if (options.watermarkSpacingX !== undefined) config.watermark.spacingX = options.watermarkSpacingX;
+        if (options.watermarkSpacingY !== undefined) config.watermark.spacingY = options.watermarkSpacingY;
       }
       
       // 确定输入源

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhaoshijun/compress",
-  "version": "1.1.5",
+  "version": "1.2.0",
   "description": "Image compression CLI and Vite plugin",
   "type": "module",
   "bin": {

package/src/config/defaults.js

@@ -28,11 +28,22 @@ export const defaultConfig = {
   suffix: '.min',
   backup: false,
   watermark: {
+    mode: 'text',
     text: '',
     opacity: 0.5,
     density: 3,
     color: '#ffffff',
-    fontSize: 24
+    fontSize: 24,
+    imagePath: '',
+    x: 0,
+    y: 0,
+    width: null,
+    height: null,
+    position: 'top-left',
+    padding: 10,
+    angle: -30,
+    spacingX: 100,
+    spacingY: 100
   },
   vite: {
     cache: true

package/src/core/compressor.js

@@ -1,6 +1,6 @@
 import sharp from 'sharp';
 import path from 'path';
-import { addWatermark } from './watermark.js';
+import { addWatermark, addImageWatermark, addTiledImageWatermark } from './watermark.js';
 
 /**
  * 压缩图片
@@ -38,9 +38,22 @@ export async function compressImage(input, options, filePath) {
   const format = resizedMetadata.format;
   
   // 先添加水印（如果需要）
-  if (options.watermark && options.watermark.text && options.watermark.text.trim() !== '') {
-    const watermarkedBuffer = await addWatermark(instance, options.watermark, resizedMetadata);
-    instance = sharp(watermarkedBuffer);
+  if (options.watermark) {
+    // 文本水印
+    if (options.watermark.text && options.watermark.text.trim() !== '') {
+      const watermarkedBuffer = await addWatermark(instance, options.watermark, resizedMetadata);
+      instance = sharp(watermarkedBuffer);
+    }
+    // 单个图片水印
+    else if (options.watermark.imagePath && options.watermark.mode !== 'tiled') {
+      const watermarkedBuffer = await addImageWatermark(instance, options.watermark);
+      instance = sharp(watermarkedBuffer);
+    }
+    // 平铺图片水印
+    else if (options.watermark.imagePath && options.watermark.mode === 'tiled') {
+      const watermarkedBuffer = await addTiledImageWatermark(instance, options.watermark, resizedMetadata);
+      instance = sharp(watermarkedBuffer);
+    }
   }
 
   // 再进行压缩

package/src/core/watermark.js

@@ -1,4 +1,6 @@
 import sharp from 'sharp';
+import path from 'path';
+import fs from 'fs-extra';
 
 /**
  * 创建单个水印文本的 SVG
@@ -155,3 +157,246 @@ export async function addWatermark(sharpInstance, watermarkOptions, providedMeta
   
   return result;
 }
+
+/**
+ * 添加单个图片水印
+ * @param {Sharp} sharpInstance - sharp 实例
+ * @param {Object} options - 图片水印配置
+ * @param {string} options.imagePath - 水印图片路径（绝对或相对路径）
+ * @param {number} [options.x=0] - 水印 X 坐标
+ * @param {number} [options.y=0] - 水印 Y 坐标
+ * @param {number} [options.width] - 水印宽度（不设置则保持原尺寸）
+ * @param {number} [options.height] - 水印高度（不设置则保持原尺寸）
+ * @param {number} [options.opacity=1] - 水印透明度 (0-1)
+ * @param {string} [options.position='top-left'] - 水印位置（top-left, top-right, bottom-left, bottom-right, center）
+ * @param {number} [options.padding=10] - 边距（当使用 position 时生效）
+ * @returns {Promise<Buffer>} 添加水印后的图片 Buffer
+ */
+export async function addImageWatermark(sharpInstance, options) {
+  const { 
+    imagePath, 
+    x = 0, 
+    y = 0, 
+    width, 
+    height, 
+    opacity = 1, 
+    position = 'top-left',
+    padding = 10
+  } = options;
+  
+  if (!imagePath) {
+    throw new Error('Watermark image path is required');
+  }
+  
+  if (opacity < 0 || opacity > 1) {
+    throw new Error('Opacity must be between 0 and 1');
+  }
+  
+  const targetMetadata = await sharpInstance.metadata();
+  
+  let watermarkPath = imagePath;
+  
+  if (!path.isAbsolute(imagePath)) {
+    watermarkPath = path.resolve(process.cwd(), imagePath);
+  }
+  
+  if (!await fs.pathExists(watermarkPath)) {
+    throw new Error(`Watermark image not found: ${watermarkPath}`);
+  }
+  
+  let watermarkImage = sharp(watermarkPath);
+  const watermarkMeta = await watermarkImage.metadata();
+  
+  if (width || height) {
+    watermarkImage = watermarkImage.resize({
+      width: width || undefined,
+      height: height || undefined,
+      fit: 'inside'
+    });
+  }
+  
+  if (opacity < 1) {
+    const watermarkBuffer = await watermarkImage.toBuffer();
+    watermarkImage = sharp(watermarkBuffer).ensureAlpha();
+    const { data } = await watermarkImage.raw().toBuffer({ resolveWithObject: true });
+    
+    for (let i = 3; i < data.length; i += 4) {
+      data[i] = Math.floor(data[i] * opacity);
+    }
+    
+    watermarkImage = sharp(data, {
+      raw: {
+        width: watermarkMeta.width,
+        height: watermarkMeta.height,
+        channels: 4
+      }
+    });
+  }
+  
+  const watermarkBuffer = await watermarkImage.toBuffer();
+  const finalWatermarkMeta = await sharp(watermarkBuffer).metadata();
+  
+  let compositeX = x;
+  let compositeY = y;
+  
+  if (position !== 'custom') {
+    switch (position) {
+      case 'top-left':
+        compositeX = padding;
+        compositeY = padding;
+        break;
+      case 'top-right':
+        compositeX = targetMetadata.width - finalWatermarkMeta.width - padding;
+        compositeY = padding;
+        break;
+      case 'bottom-left':
+        compositeX = padding;
+        compositeY = targetMetadata.height - finalWatermarkMeta.height - padding;
+        break;
+      case 'bottom-right':
+        compositeX = targetMetadata.width - finalWatermarkMeta.width - padding;
+        compositeY = targetMetadata.height - finalWatermarkMeta.height - padding;
+        break;
+      case 'center':
+        compositeX = Math.floor((targetMetadata.width - finalWatermarkMeta.width) / 2);
+        compositeY = Math.floor((targetMetadata.height - finalWatermarkMeta.height) / 2);
+        break;
+    }
+  }
+  
+  const result = await sharpInstance
+    .composite([{ 
+      input: watermarkBuffer, 
+      left: compositeX, 
+      top: compositeY,
+      blend: 'over'
+    }])
+    .toBuffer();
+  
+  return result;
+}
+
+/**
+ * 添加平铺图片水印
+ * @param {Sharp} sharpInstance - sharp 实例
+ * @param {Object} options - 平铺图片水印配置
+ * @param {string} options.imagePath - 水印图片路径（绝对或相对路径）
+ * @param {number} [options.width] - 水印宽度（不设置则保持原尺寸）
+ * @param {number} [options.height] - 水印高度（不设置则保持原尺寸）
+ * @param {number} [options.opacity=0.5] - 水印透明度 (0-1)
+ * @param {number} [options.angle=-30] - 水印倾斜角度（度）
+ * @param {number} [options.spacingX=100] - 水印水平间隔
+ * @param {number} [options.spacingY=100] - 水印垂直间隔
+ * @param {Object} [providedMetadata] - 提供的 metadata（避免重复获取）
+ * @returns {Promise<Buffer>} 添加水印后的图片 Buffer
+ */
+export async function addTiledImageWatermark(sharpInstance, options, providedMetadata) {
+  const { 
+    imagePath, 
+    width, 
+    height, 
+    opacity = 0.5, 
+    angle = -30,
+    spacingX = 100,
+    spacingY = 100
+  } = options;
+  
+  if (!imagePath) {
+    throw new Error('Watermark image path is required');
+  }
+  
+  if (opacity < 0 || opacity > 1) {
+    throw new Error('Opacity must be between 0 and 1');
+  }
+  
+  const metadata = providedMetadata || await sharpInstance.metadata();
+  
+  let watermarkPath = imagePath;
+  
+  if (!path.isAbsolute(imagePath)) {
+    watermarkPath = path.resolve(process.cwd(), imagePath);
+  }
+  
+  if (!await fs.pathExists(watermarkPath)) {
+    throw new Error(`Watermark image not found: ${watermarkPath}`);
+  }
+  
+  let watermarkImage = sharp(watermarkPath);
+  const watermarkMeta = await watermarkImage.metadata();
+  
+  if (width || height) {
+    watermarkImage = watermarkImage.resize({
+      width: width || undefined,
+      height: height || undefined,
+      fit: 'inside'
+    });
+  }
+  
+  if (opacity < 1) {
+    const watermarkBuffer = await watermarkImage.toBuffer();
+    watermarkImage = sharp(watermarkBuffer).ensureAlpha();
+    const { data, info } = await watermarkImage.raw().toBuffer({ resolveWithObject: true });
+    
+    for (let i = 3; i < data.length; i += 4) {
+      data[i] = Math.floor(data[i] * opacity);
+    }
+    
+    watermarkImage = sharp(data, {
+      raw: {
+        width: info.width,
+        height: info.height,
+        channels: 4
+      }
+    });
+  }
+  
+  if (angle !== 0) {
+    const watermarkBuffer = await watermarkImage.toBuffer();
+    const rotatedMeta = await sharp(watermarkBuffer).metadata();
+    const radians = angle * Math.PI / 180;
+    const cos = Math.abs(Math.cos(radians));
+    const sin = Math.abs(Math.sin(radians));
+    const newWidth = Math.ceil(rotatedMeta.width * cos + rotatedMeta.height * sin);
+    const newHeight = Math.ceil(rotatedMeta.width * sin + rotatedMeta.height * cos);
+    
+    watermarkImage = sharp(watermarkBuffer).rotate(angle, {
+      background: { r: 0, g: 0, b: 0, alpha: 0 }
+    }).resize(newWidth, newHeight);
+  }
+  
+  const watermarkBuffer = await watermarkImage.toBuffer();
+  const finalWatermarkMeta = await sharp(watermarkBuffer).metadata();
+  
+  const cols = Math.ceil(metadata.width / spacingX) + 1;
+  const rows = Math.ceil(metadata.height / spacingY) + 1;
+  
+  const composites = [];
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      composites.push({
+        input: watermarkBuffer,
+        left: col * spacingX,
+        top: row * spacingY
+      });
+    }
+  }
+  
+  const tiledWatermark = await sharp({
+    create: {
+      width: cols * spacingX + finalWatermarkMeta.width,
+      height: rows * spacingY + finalWatermarkMeta.height,
+      channels: 4,
+      background: { r: 0, g: 0, b: 0, alpha: 0 }
+    }
+  })
+  .composite(composites)
+  .extract({ left: 0, top: 0, width: metadata.width, height: metadata.height })
+  .png()
+  .toBuffer();
+  
+  const result = await sharpInstance
+    .composite([{ input: tiledWatermark, blend: 'over' }])
+    .toBuffer();
+  
+  return result;
+}