assistsx-js 0.1.22 → 0.1.23

package/dist/imageutils/image-utils.d.ts

@@ -77,6 +77,7 @@ export declare class ImageUtils {
      * @param options.scaleWidth 缩放宽度（可选）
      * @param options.scaleHeight 缩放高度（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -84,6 +85,7 @@ export declare class ImageUtils {
         scaleWidth?: number;
         scaleHeight?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -95,6 +97,7 @@ export declare class ImageUtils {
      * @param options.width 裁剪宽度（可选，不提供则裁剪到图片右边界）
      * @param options.height 裁剪高度（可选，不提供则裁剪到图片下边界）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -104,6 +107,7 @@ export declare class ImageUtils {
         width?: number;
         height?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -115,6 +119,7 @@ export declare class ImageUtils {
      * @param options.px X轴倾斜点（可选）
      * @param options.py Y轴倾斜点（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -124,6 +129,7 @@ export declare class ImageUtils {
         px?: number;
         py?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -134,6 +140,7 @@ export declare class ImageUtils {
      * @param options.px 旋转中心X坐标（可选）
      * @param options.py 旋转中心Y坐标（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -142,6 +149,7 @@ export declare class ImageUtils {
         px?: number;
         py?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -149,11 +157,13 @@ export declare class ImageUtils {
      * @param imagePath 图片路径
      * @param options 选项
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     toRound(imagePath: string, options?: {
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -162,12 +172,14 @@ export declare class ImageUtils {
      * @param options 选项
      * @param options.radius 圆角半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     toRoundCorner(imagePath: string, options?: {
         radius?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -178,6 +190,7 @@ export declare class ImageUtils {
      * @param options.color 边框颜色，默认"#000000"
      * @param options.cornerRadius 圆角半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -186,6 +199,7 @@ export declare class ImageUtils {
         color?: string;
         cornerRadius?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -195,6 +209,7 @@ export declare class ImageUtils {
      * @param options.borderSize 边框大小，默认0
      * @param options.color 边框颜色，默认"#000000"
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -202,6 +217,7 @@ export declare class ImageUtils {
         borderSize?: number;
         color?: string;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -210,12 +226,14 @@ export declare class ImageUtils {
      * @param options 选项
      * @param options.reflectionHeight 倒影高度，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     addReflection(imagePath: string, options?: {
         reflectionHeight?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -228,6 +246,7 @@ export declare class ImageUtils {
      * @param options.color 文字颜色，默认"#000000"
      * @param options.size 文字大小，默认16
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -238,6 +257,7 @@ export declare class ImageUtils {
         color?: string;
         size?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -249,6 +269,7 @@ export declare class ImageUtils {
      * @param options.y 水印Y坐标，默认0
      * @param options.alpha 透明度，默认255
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -258,6 +279,7 @@ export declare class ImageUtils {
         y?: number;
         alpha?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -265,11 +287,13 @@ export declare class ImageUtils {
      * @param imagePath 图片路径
      * @param options 选项
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     toAlpha(imagePath: string, options?: {
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -277,11 +301,13 @@ export declare class ImageUtils {
      * @param imagePath 图片路径
      * @param options 选项
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     toGray(imagePath: string, options?: {
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -291,6 +317,7 @@ export declare class ImageUtils {
      * @param options.radius 模糊半径，默认0
      * @param options.scale 缩放比例，默认1
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -298,6 +325,7 @@ export declare class ImageUtils {
         radius?: number;
         scale?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -306,12 +334,14 @@ export declare class ImageUtils {
      * @param options 选项
      * @param options.radius 模糊半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     renderScriptBlur(imagePath: string, options?: {
         radius?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -320,12 +350,14 @@ export declare class ImageUtils {
      * @param options 选项
      * @param options.radius 模糊半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     stackBlur(imagePath: string, options?: {
         radius?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -335,6 +367,7 @@ export declare class ImageUtils {
      * @param options.scaleWidth 缩放宽度（可选）
      * @param options.scaleHeight 缩放高度（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<压缩后的图片路径>
      */
@@ -342,6 +375,7 @@ export declare class ImageUtils {
         scaleWidth?: number;
         scaleHeight?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**
@@ -366,12 +400,14 @@ export declare class ImageUtils {
      * @param options 选项
      * @param options.sampleSize 采样大小，默认1
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<压缩后的图片路径>
      */
     compressBySampleSize(imagePath: string, options?: {
         sampleSize?: number;
         savePath?: string;
+        format?: "PNG" | "JPEG" | "JPG" | "WEBP";
         timeout?: number;
     }): Promise<string>;
     /**

package/dist/imageutils/image-utils.js

@@ -128,13 +128,14 @@ export class ImageUtils {
      * @param options.scaleWidth 缩放宽度（可选）
      * @param options.scaleHeight 缩放高度（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async scale(imagePath, options = {}) {
         var _a;
-        const { scaleWidth, scaleHeight, savePath, timeout } = options;
-        const response = await this.asyncCall("scale", { imagePath, scaleWidth, scaleHeight, savePath }, timeout);
+        const { scaleWidth, scaleHeight, savePath, format, timeout } = options;
+        const response = await this.asyncCall("scale", { imagePath, scaleWidth, scaleHeight, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "缩放图片失败");
         }
@@ -149,13 +150,14 @@ export class ImageUtils {
      * @param options.width 裁剪宽度（可选，不提供则裁剪到图片右边界）
      * @param options.height 裁剪高度（可选，不提供则裁剪到图片下边界）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async clip(imagePath, options = {}) {
         var _a;
-        const { x = 0, y = 0, width, height, savePath, timeout } = options;
-        const response = await this.asyncCall("clip", { imagePath, x, y, width, height, savePath }, timeout);
+        const { x = 0, y = 0, width, height, savePath, format, timeout } = options;
+        const response = await this.asyncCall("clip", { imagePath, x, y, width, height, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "裁剪图片失败");
         }
@@ -170,13 +172,14 @@ export class ImageUtils {
      * @param options.px X轴倾斜点（可选）
      * @param options.py Y轴倾斜点（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async skew(imagePath, options = {}) {
         var _a;
-        const { kx = 0, ky = 0, px, py, savePath, timeout } = options;
-        const response = await this.asyncCall("skew", { imagePath, kx, ky, px, py, savePath }, timeout);
+        const { kx = 0, ky = 0, px, py, savePath, format, timeout } = options;
+        const response = await this.asyncCall("skew", { imagePath, kx, ky, px, py, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "倾斜图片失败");
         }
@@ -190,13 +193,14 @@ export class ImageUtils {
      * @param options.px 旋转中心X坐标（可选）
      * @param options.py 旋转中心Y坐标（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async rotate(imagePath, options = {}) {
         var _a;
-        const { degree = 0, px, py, savePath, timeout } = options;
-        const response = await this.asyncCall("rotate", { imagePath, degree, px, py, savePath }, timeout);
+        const { degree = 0, px, py, savePath, format, timeout } = options;
+        const response = await this.asyncCall("rotate", { imagePath, degree, px, py, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "旋转图片失败");
         }
@@ -207,13 +211,14 @@ export class ImageUtils {
      * @param imagePath 图片路径
      * @param options 选项
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async toRound(imagePath, options = {}) {
         var _a;
-        const { savePath, timeout } = options;
-        const response = await this.asyncCall("toRound", { imagePath, savePath }, timeout);
+        const { savePath, format, timeout } = options;
+        const response = await this.asyncCall("toRound", { imagePath, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "转为圆形图片失败");
         }
@@ -225,13 +230,14 @@ export class ImageUtils {
      * @param options 选项
      * @param options.radius 圆角半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async toRoundCorner(imagePath, options = {}) {
         var _a;
-        const { radius = 0, savePath, timeout } = options;
-        const response = await this.asyncCall("toRoundCorner", { imagePath, radius, savePath }, timeout);
+        const { radius = 0, savePath, format, timeout } = options;
+        const response = await this.asyncCall("toRoundCorner", { imagePath, radius, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "转为圆角图片失败");
         }
@@ -245,13 +251,14 @@ export class ImageUtils {
      * @param options.color 边框颜色，默认"#000000"
      * @param options.cornerRadius 圆角半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async addCornerBorder(imagePath, options = {}) {
         var _a;
-        const { borderSize = 0, color = "#000000", cornerRadius = 0, savePath, timeout } = options;
-        const response = await this.asyncCall("addCornerBorder", { imagePath, borderSize, color, cornerRadius, savePath }, timeout);
+        const { borderSize = 0, color = "#000000", cornerRadius = 0, savePath, format, timeout } = options;
+        const response = await this.asyncCall("addCornerBorder", { imagePath, borderSize, color, cornerRadius, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "添加圆角边框失败");
         }
@@ -264,13 +271,14 @@ export class ImageUtils {
      * @param options.borderSize 边框大小，默认0
      * @param options.color 边框颜色，默认"#000000"
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async addCircleBorder(imagePath, options = {}) {
         var _a;
-        const { borderSize = 0, color = "#000000", savePath, timeout } = options;
-        const response = await this.asyncCall("addCircleBorder", { imagePath, borderSize, color, savePath }, timeout);
+        const { borderSize = 0, color = "#000000", savePath, format, timeout } = options;
+        const response = await this.asyncCall("addCircleBorder", { imagePath, borderSize, color, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "添加圆形边框失败");
         }
@@ -282,13 +290,14 @@ export class ImageUtils {
      * @param options 选项
      * @param options.reflectionHeight 倒影高度，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async addReflection(imagePath, options = {}) {
         var _a;
-        const { reflectionHeight = 0, savePath, timeout } = options;
-        const response = await this.asyncCall("addReflection", { imagePath, reflectionHeight, savePath }, timeout);
+        const { reflectionHeight = 0, savePath, format, timeout } = options;
+        const response = await this.asyncCall("addReflection", { imagePath, reflectionHeight, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "添加倒影失败");
         }
@@ -304,13 +313,14 @@ export class ImageUtils {
      * @param options.color 文字颜色，默认"#000000"
      * @param options.size 文字大小，默认16
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async addTextWatermark(imagePath, options = {}) {
         var _a;
-        const { text = "", x = 0, y = 0, color = "#000000", size = 16, savePath, timeout } = options;
-        const response = await this.asyncCall("addTextWatermark", { imagePath, text, x, y, color, size, savePath }, timeout);
+        const { text = "", x = 0, y = 0, color = "#000000", size = 16, savePath, format, timeout } = options;
+        const response = await this.asyncCall("addTextWatermark", { imagePath, text, x, y, color, size, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "添加文字水印失败");
         }
@@ -325,13 +335,14 @@ export class ImageUtils {
      * @param options.y 水印Y坐标，默认0
      * @param options.alpha 透明度，默认255
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async addImageWatermark(imagePath, options) {
         var _a;
-        const { watermarkPath, x = 0, y = 0, alpha = 255, savePath, timeout } = options;
-        const response = await this.asyncCall("addImageWatermark", { imagePath, watermarkPath, x, y, alpha, savePath }, timeout);
+        const { watermarkPath, x = 0, y = 0, alpha = 255, savePath, format, timeout } = options;
+        const response = await this.asyncCall("addImageWatermark", { imagePath, watermarkPath, x, y, alpha, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "添加图片水印失败");
         }
@@ -342,13 +353,14 @@ export class ImageUtils {
      * @param imagePath 图片路径
      * @param options 选项
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async toAlpha(imagePath, options = {}) {
         var _a;
-        const { savePath, timeout } = options;
-        const response = await this.asyncCall("toAlpha", { imagePath, savePath }, timeout);
+        const { savePath, format, timeout } = options;
+        const response = await this.asyncCall("toAlpha", { imagePath, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "转为 alpha 位图失败");
         }
@@ -359,13 +371,14 @@ export class ImageUtils {
      * @param imagePath 图片路径
      * @param options 选项
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async toGray(imagePath, options = {}) {
         var _a;
-        const { savePath, timeout } = options;
-        const response = await this.asyncCall("toGray", { imagePath, savePath }, timeout);
+        const { savePath, format, timeout } = options;
+        const response = await this.asyncCall("toGray", { imagePath, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "转为灰度图片失败");
         }
@@ -378,13 +391,14 @@ export class ImageUtils {
      * @param options.radius 模糊半径，默认0
      * @param options.scale 缩放比例，默认1
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async fastBlur(imagePath, options = {}) {
         var _a;
-        const { radius = 0, scale = 1, savePath, timeout } = options;
-        const response = await this.asyncCall("fastBlur", { imagePath, radius, scale, savePath }, timeout);
+        const { radius = 0, scale = 1, savePath, format, timeout } = options;
+        const response = await this.asyncCall("fastBlur", { imagePath, radius, scale, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "快速模糊失败");
         }
@@ -396,13 +410,14 @@ export class ImageUtils {
      * @param options 选项
      * @param options.radius 模糊半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async renderScriptBlur(imagePath, options = {}) {
         var _a;
-        const { radius = 0, savePath, timeout } = options;
-        const response = await this.asyncCall("renderScriptBlur", { imagePath, radius, savePath }, timeout);
+        const { radius = 0, savePath, format, timeout } = options;
+        const response = await this.asyncCall("renderScriptBlur", { imagePath, radius, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "RenderScript 模糊失败");
         }
@@ -414,13 +429,14 @@ export class ImageUtils {
      * @param options 选项
      * @param options.radius 模糊半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
     async stackBlur(imagePath, options = {}) {
         var _a;
-        const { radius = 0, savePath, timeout } = options;
-        const response = await this.asyncCall("stackBlur", { imagePath, radius, savePath }, timeout);
+        const { radius = 0, savePath, format, timeout } = options;
+        const response = await this.asyncCall("stackBlur", { imagePath, radius, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "Stack 模糊失败");
         }
@@ -434,13 +450,14 @@ export class ImageUtils {
      * @param options.scaleWidth 缩放宽度（可选）
      * @param options.scaleHeight 缩放高度（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<压缩后的图片路径>
      */
     async compressByScale(imagePath, options = {}) {
         var _a;
-        const { scaleWidth, scaleHeight, savePath, timeout } = options;
-        const response = await this.asyncCall("compressByScale", { imagePath, scaleWidth, scaleHeight, savePath }, timeout);
+        const { scaleWidth, scaleHeight, savePath, format, timeout } = options;
+        const response = await this.asyncCall("compressByScale", { imagePath, scaleWidth, scaleHeight, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "按缩放压缩失败");
         }
@@ -471,13 +488,14 @@ export class ImageUtils {
      * @param options 选项
      * @param options.sampleSize 采样大小，默认1
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<压缩后的图片路径>
      */
     async compressBySampleSize(imagePath, options = {}) {
         var _a;
-        const { sampleSize = 1, savePath, timeout } = options;
-        const response = await this.asyncCall("compressBySampleSize", { imagePath, sampleSize, savePath }, timeout);
+        const { sampleSize = 1, savePath, format, timeout } = options;
+        const response = await this.asyncCall("compressBySampleSize", { imagePath, sampleSize, savePath, format }, timeout);
         if (!response.isSuccess()) {
             throw new Error(((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || "按采样大小压缩失败");
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "assistsx-js",
-    "version": "0.1.22",
+    "version": "0.1.23",
     "description": "assistsx-js自动化开发SDK",
     "main": "dist/index.js",
     "module": "dist/index.js",

package/src/imageutils/image-utils.ts

@@ -180,6 +180,7 @@ export class ImageUtils {
      * @param options.scaleWidth 缩放宽度（可选）
      * @param options.scaleHeight 缩放高度（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -189,13 +190,14 @@ export class ImageUtils {
             scaleWidth?: number;
             scaleHeight?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { scaleWidth, scaleHeight, savePath, timeout } = options;
+        const { scaleWidth, scaleHeight, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "scale",
-            { imagePath, scaleWidth, scaleHeight, savePath },
+            { imagePath, scaleWidth, scaleHeight, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -213,6 +215,7 @@ export class ImageUtils {
      * @param options.width 裁剪宽度（可选，不提供则裁剪到图片右边界）
      * @param options.height 裁剪高度（可选，不提供则裁剪到图片下边界）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -224,13 +227,14 @@ export class ImageUtils {
             width?: number;
             height?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { x = 0, y = 0, width, height, savePath, timeout } = options;
+        const { x = 0, y = 0, width, height, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "clip",
-            { imagePath, x, y, width, height, savePath },
+            { imagePath, x, y, width, height, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -248,6 +252,7 @@ export class ImageUtils {
      * @param options.px X轴倾斜点（可选）
      * @param options.py Y轴倾斜点（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -259,13 +264,14 @@ export class ImageUtils {
             px?: number;
             py?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { kx = 0, ky = 0, px, py, savePath, timeout } = options;
+        const { kx = 0, ky = 0, px, py, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "skew",
-            { imagePath, kx, ky, px, py, savePath },
+            { imagePath, kx, ky, px, py, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -282,6 +288,7 @@ export class ImageUtils {
      * @param options.px 旋转中心X坐标（可选）
      * @param options.py 旋转中心Y坐标（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -292,13 +299,14 @@ export class ImageUtils {
             px?: number;
             py?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { degree = 0, px, py, savePath, timeout } = options;
+        const { degree = 0, px, py, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "rotate",
-            { imagePath, degree, px, py, savePath },
+            { imagePath, degree, px, py, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -312,6 +320,7 @@ export class ImageUtils {
      * @param imagePath 图片路径
      * @param options 选项
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -319,13 +328,14 @@ export class ImageUtils {
         imagePath: string,
         options: {
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { savePath, timeout } = options;
+        const { savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "toRound",
-            { imagePath, savePath },
+            { imagePath, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -340,6 +350,7 @@ export class ImageUtils {
      * @param options 选项
      * @param options.radius 圆角半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -348,13 +359,14 @@ export class ImageUtils {
         options: {
             radius?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { radius = 0, savePath, timeout } = options;
+        const { radius = 0, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "toRoundCorner",
-            { imagePath, radius, savePath },
+            { imagePath, radius, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -371,6 +383,7 @@ export class ImageUtils {
      * @param options.color 边框颜色，默认"#000000"
      * @param options.cornerRadius 圆角半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -381,13 +394,14 @@ export class ImageUtils {
             color?: string;
             cornerRadius?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { borderSize = 0, color = "#000000", cornerRadius = 0, savePath, timeout } = options;
+        const { borderSize = 0, color = "#000000", cornerRadius = 0, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "addCornerBorder",
-            { imagePath, borderSize, color, cornerRadius, savePath },
+            { imagePath, borderSize, color, cornerRadius, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -403,6 +417,7 @@ export class ImageUtils {
      * @param options.borderSize 边框大小，默认0
      * @param options.color 边框颜色，默认"#000000"
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -412,13 +427,14 @@ export class ImageUtils {
             borderSize?: number;
             color?: string;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { borderSize = 0, color = "#000000", savePath, timeout } = options;
+        const { borderSize = 0, color = "#000000", savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "addCircleBorder",
-            { imagePath, borderSize, color, savePath },
+            { imagePath, borderSize, color, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -433,6 +449,7 @@ export class ImageUtils {
      * @param options 选项
      * @param options.reflectionHeight 倒影高度，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -441,13 +458,14 @@ export class ImageUtils {
         options: {
             reflectionHeight?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { reflectionHeight = 0, savePath, timeout } = options;
+        const { reflectionHeight = 0, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "addReflection",
-            { imagePath, reflectionHeight, savePath },
+            { imagePath, reflectionHeight, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -466,6 +484,7 @@ export class ImageUtils {
      * @param options.color 文字颜色，默认"#000000"
      * @param options.size 文字大小，默认16
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -478,13 +497,14 @@ export class ImageUtils {
             color?: string;
             size?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { text = "", x = 0, y = 0, color = "#000000", size = 16, savePath, timeout } = options;
+        const { text = "", x = 0, y = 0, color = "#000000", size = 16, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "addTextWatermark",
-            { imagePath, text, x, y, color, size, savePath },
+            { imagePath, text, x, y, color, size, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -502,6 +522,7 @@ export class ImageUtils {
      * @param options.y 水印Y坐标，默认0
      * @param options.alpha 透明度，默认255
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -513,13 +534,14 @@ export class ImageUtils {
             y?: number;
             alpha?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         }
     ): Promise<string> {
-        const { watermarkPath, x = 0, y = 0, alpha = 255, savePath, timeout } = options;
+        const { watermarkPath, x = 0, y = 0, alpha = 255, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "addImageWatermark",
-            { imagePath, watermarkPath, x, y, alpha, savePath },
+            { imagePath, watermarkPath, x, y, alpha, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -533,6 +555,7 @@ export class ImageUtils {
      * @param imagePath 图片路径
      * @param options 选项
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -540,13 +563,14 @@ export class ImageUtils {
         imagePath: string,
         options: {
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { savePath, timeout } = options;
+        const { savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "toAlpha",
-            { imagePath, savePath },
+            { imagePath, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -560,6 +584,7 @@ export class ImageUtils {
      * @param imagePath 图片路径
      * @param options 选项
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -567,13 +592,14 @@ export class ImageUtils {
         imagePath: string,
         options: {
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { savePath, timeout } = options;
+        const { savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "toGray",
-            { imagePath, savePath },
+            { imagePath, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -589,6 +615,7 @@ export class ImageUtils {
      * @param options.radius 模糊半径，默认0
      * @param options.scale 缩放比例，默认1
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -598,13 +625,14 @@ export class ImageUtils {
             radius?: number;
             scale?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { radius = 0, scale = 1, savePath, timeout } = options;
+        const { radius = 0, scale = 1, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "fastBlur",
-            { imagePath, radius, scale, savePath },
+            { imagePath, radius, scale, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -619,6 +647,7 @@ export class ImageUtils {
      * @param options 选项
      * @param options.radius 模糊半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -627,13 +656,14 @@ export class ImageUtils {
         options: {
             radius?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { radius = 0, savePath, timeout } = options;
+        const { radius = 0, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "renderScriptBlur",
-            { imagePath, radius, savePath },
+            { imagePath, radius, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -648,6 +678,7 @@ export class ImageUtils {
      * @param options 选项
      * @param options.radius 模糊半径，默认0
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<处理后的图片路径>
      */
@@ -656,13 +687,14 @@ export class ImageUtils {
         options: {
             radius?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { radius = 0, savePath, timeout } = options;
+        const { radius = 0, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "stackBlur",
-            { imagePath, radius, savePath },
+            { imagePath, radius, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -680,6 +712,7 @@ export class ImageUtils {
      * @param options.scaleWidth 缩放宽度（可选）
      * @param options.scaleHeight 缩放高度（可选）
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<压缩后的图片路径>
      */
@@ -689,13 +722,14 @@ export class ImageUtils {
             scaleWidth?: number;
             scaleHeight?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { scaleWidth, scaleHeight, savePath, timeout } = options;
+        const { scaleWidth, scaleHeight, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "compressByScale",
-            { imagePath, scaleWidth, scaleHeight, savePath },
+            { imagePath, scaleWidth, scaleHeight, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {
@@ -741,6 +775,7 @@ export class ImageUtils {
      * @param options 选项
      * @param options.sampleSize 采样大小，默认1
      * @param options.savePath 保存路径（可选）
+     * @param options.format 图片格式，支持 "PNG"、"JPEG"、"JPG"、"WEBP"，默认"PNG"
      * @param options.timeout 超时时间(秒)，默认30秒
      * @returns Promise<压缩后的图片路径>
      */
@@ -749,13 +784,14 @@ export class ImageUtils {
         options: {
             sampleSize?: number;
             savePath?: string;
+            format?: "PNG" | "JPEG" | "JPG" | "WEBP";
             timeout?: number;
         } = {}
     ): Promise<string> {
-        const { sampleSize = 1, savePath, timeout } = options;
+        const { sampleSize = 1, savePath, format, timeout } = options;
         const response = await this.asyncCall(
             "compressBySampleSize",
-            { imagePath, sampleSize, savePath },
+            { imagePath, sampleSize, savePath, format },
             timeout
         );
         if (!response.isSuccess()) {