@rsbuild/plugin-image-compress 1.0.2 → 1.1.0

package/README.md

@@ -9,6 +9,7 @@ With the image compression plugin, image assets used in the project can be compr
    <img src="https://img.shields.io/npm/v/@rsbuild/plugin-image-compress?style=flat-square&colorA=564341&colorB=EDED91" alt="npm version" />
   </a>
   <img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square&colorA=564341&colorB=EDED91" alt="license" />
+  <a href="https://npmcharts.com/compare/@rsbuild/plugin-image-compress?minimal=true"><img src="https://img.shields.io/npm/dm/@rsbuild/plugin-image-compress.svg?style=flat-square&colorA=564341&colorB=EDED91" alt="downloads" /></a>
 </p>
 
 ## Usage
@@ -30,10 +31,7 @@ export default {
 };
 ```
 
-## Options
-
-The plugin accepts an array of compressor configuration options, each of which can be either a string or an object. The string can be the name of a built-in compressor and its default configuration enabled.
-Or use the object format configuration and specify the compressor in the `use` field. The remaining fields of the object will be used as compressor configuration options.
+## Default Compressors
 
 By default, the plugin will enable `jpeg`, `png`, `ico` image compressors, which are equivalent to the following two examples:
 
@@ -45,19 +43,48 @@ pluginImageCompress(["jpeg", "png", "ico"]);
 pluginImageCompress([{ use: "jpeg" }, { use: "png" }, { use: "ico" }]);
 ```
 
+## Supported Compressors
+
+The plugin supports the following compressors:
+
+- `jpeg`: For JPEG images.
+- `png`: For PNG images.
+- `pngLossless`: For PNG images with lossless compression.
+- `ico`: For ICO images.
+- `svg`: For SVG images.
+- `avif`: For AVIF images.
+
+Only SVG are compressed by `svgo`, other compressors are compressed by `@napi-rs/image`.
+
+## Options
+
+The plugin accepts an array of compressor configuration options, each of which can be either a string or an object. The string can be the name of a built-in compressor and its default configuration enabled.
+
+Or use the object format configuration and specify the compressor in the `use` field. The remaining fields of the object will be used as compressor configuration options.
+
 The default configuration can be overridden by specifying a configuration option.
 For example, to allow the jpeg compressor to recognize new extension name and to set the quality of the png compressor.
 
 ```js
 pluginImageCompress([
+  // Options for @napi-rs/image `compressJpeg` method
   { use: "jpeg", test: /\.(?:jpg|jpeg|jpe)$/ },
+  // Options for @napi-rs/image `pngQuantize` method
   { use: "png", minQuality: 50 },
-  "ico",
+  // Options for @napi-rs/image `avif` method
+  { use: "avif", quality: 80 },
+  // Options for svgo
+  { use: 'svg', floatPrecision: 2 }
+  // No options yet
+  { use: "ico" },
 ]);
 ```
 
-The default `png` compressor is lossy.
-If you want to replace it with a lossless compressor, you can use the following configuration.
+For more information on compressors, please visit [@napi-rs/image](https://image.napi.rs/docs).
+
+## Lossless PNG
+
+The default `png` compressor is lossy. If you want to replace it with a lossless compressor, you can use the following configuration.
 
 ```js
 pluginImageCompress(["jpeg", "pngLossless", "ico"]);
@@ -71,8 +98,6 @@ For example, the `png` compressor will take precedence over the `pngLossless` co
 pluginImageCompress(["jpeg", "pngLossless", "ico", "png"]);
 ```
 
-For more information on compressors, please visit [@napi-rs/image](https://image.napi.rs/docs).
-
 ## License
 
 [MIT](./LICENSE).

package/dist/index.cjs

@@ -1,226 +1,253 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
-  PLUGIN_IMAGE_COMPRESS_NAME: () => PLUGIN_IMAGE_COMPRESS_NAME,
-  pluginImageCompress: () => pluginImageCompress
+// The require scope
+var __webpack_require__ = {};
+/************************************************************************/ // webpack/runtime/compat_get_default_export
+(()=>{
+    // getDefaultExport function for compatibility with non-ESM modules
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+// webpack/runtime/define_property_getters
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+// webpack/runtime/has_own_property
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+// webpack/runtime/make_namespace_object
+(()=>{
+    // define __esModule on exports
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+/************************************************************************/ var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+    DEFAULT_OPTIONS: ()=>/* binding */ DEFAULT_OPTIONS,
+    pluginImageCompress: ()=>/* binding */ pluginImageCompress,
+    PLUGIN_IMAGE_COMPRESS_NAME: ()=>/* binding */ PLUGIN_IMAGE_COMPRESS_NAME
 });
-module.exports = __toCommonJS(src_exports);
-var import_node_assert2 = __toESM(require("assert"), 1);
-
-// src/minimizer.ts
-var import_node_buffer2 = require("buffer");
-
-// src/shared/codecs.ts
-var import_node_buffer = require("buffer");
-var import_image = require("@napi-rs/image");
-var import_svgo = __toESM(require("svgo"), 1);
-var jpegCodec = {
-  handler(buf, options) {
-    return (0, import_image.compressJpeg)(buf, options);
-  },
-  defaultOptions: {
-    test: /\.(?:jpg|jpeg)$/
-  }
+const external_node_assert_namespaceObject = require("node:assert");
+var external_node_assert_default = /*#__PURE__*/ __webpack_require__.n(external_node_assert_namespaceObject);
+const external_node_buffer_namespaceObject = require("node:buffer");
+const image_namespaceObject = require("@napi-rs/image");
+const external_svgo_namespaceObject = require("svgo");
+var external_svgo_default = /*#__PURE__*/ __webpack_require__.n(external_svgo_namespaceObject);
+const jpegCodec = {
+    handler (buf, options) {
+        return (0, image_namespaceObject.compressJpeg)(buf, options);
+    },
+    defaultOptions: {
+        test: /\.(?:jpg|jpeg)$/
+    }
 };
-var pngCodec = {
-  handler(buf, options) {
-    return (0, import_image.pngQuantize)(buf, options);
-  },
-  defaultOptions: {
-    test: /\.png$/
-  }
+const pngCodec = {
+    handler (buf, options) {
+        return (0, image_namespaceObject.pngQuantize)(buf, options);
+    },
+    defaultOptions: {
+        test: /\.png$/
+    }
 };
-var pngLosslessCodec = {
-  handler(buf, options) {
-    return (0, import_image.losslessCompressPng)(buf, options);
-  },
-  defaultOptions: {
-    test: /\.png$/
-  }
+const pngLosslessCodec = {
+    handler (buf, options) {
+        return (0, image_namespaceObject.losslessCompressPng)(buf, options);
+    },
+    defaultOptions: {
+        test: /\.png$/
+    }
 };
-var icoCodec = {
-  handler(buf) {
-    return new import_image.Transformer(buf).ico();
-  },
-  defaultOptions: {
-    test: /\.(?:ico|icon)$/
-  }
+const icoCodec = {
+    handler (buf) {
+        return new image_namespaceObject.Transformer(buf).ico();
+    },
+    defaultOptions: {
+        test: /\.(?:ico|icon)$/
+    }
 };
-var svgCodec = {
-  async handler(buf, options) {
-    const result = import_svgo.default.optimize(buf.toString(), options);
-    return import_node_buffer.Buffer.from(result.data);
-  },
-  defaultOptions: {
-    test: /\.svg$/
-  }
+const avifCodec = {
+    handler (buf, options) {
+        return new image_namespaceObject.Transformer(buf).avif(options);
+    },
+    defaultOptions: {
+        test: /\.avif$/
+    }
 };
-var codecs = {
-  jpeg: jpegCodec,
-  png: pngCodec,
-  pngLossless: pngLosslessCodec,
-  ico: icoCodec,
-  svg: svgCodec
+const svgCodec = {
+    async handler (buf, options) {
+        const result = external_svgo_default().optimize(buf.toString(), options);
+        return external_node_buffer_namespaceObject.Buffer.from(result.data);
+    },
+    defaultOptions: {
+        test: /\.svg$/
+    }
 };
-var codecs_default = codecs;
-
-// src/minimizer.ts
-var IMAGE_MINIMIZER_PLUGIN_NAME = "@rsbuild/plugin-image-compress/minimizer";
-var ImageMinimizerPlugin = class {
-  constructor(options) {
-    this.name = IMAGE_MINIMIZER_PLUGIN_NAME;
-    this.options = options;
-  }
-  async optimize(compiler, compilation, assets) {
-    const cache = compilation.getCache(IMAGE_MINIMIZER_PLUGIN_NAME);
-    const { RawSource } = compiler.webpack.sources;
-    const { matchObject } = compiler.webpack.ModuleFilenameHelpers;
-    const buildError = (error, file, context) => {
-      const cause = error instanceof Error ? error : new Error();
-      const message = file && context ? `"${file}" in "${context}" from Image Minimizer:
-${cause.message}` : cause.message;
-      const ret = new compiler.webpack.WebpackError(message);
-      if (error instanceof Error) {
-        ret.error = error;
-      }
-      return ret;
-    };
-    const codec = codecs_default[this.options.use];
-    if (!codec) {
-      compilation.errors.push(
-        buildError(new Error(`Codec ${this.options.use} is not supported`))
-      );
+// biome-ignore lint/suspicious/noExplicitAny:allow any
+const codecs = {
+    jpeg: jpegCodec,
+    png: pngCodec,
+    pngLossless: pngLosslessCodec,
+    ico: icoCodec,
+    svg: svgCodec,
+    avif: avifCodec
+};
+/* ESM default export */ const shared_codecs = codecs;
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const IMAGE_MINIMIZER_PLUGIN_NAME = '@rsbuild/plugin-image-compress/minimizer';
+class ImageMinimizerPlugin {
+    async optimize(compiler, compilation, assets) {
+        const cache = compilation.getCache(IMAGE_MINIMIZER_PLUGIN_NAME);
+        const { RawSource } = compiler.webpack.sources;
+        const { matchObject } = compiler.webpack.ModuleFilenameHelpers;
+        const buildError = (error, file, context)=>{
+            const cause = error instanceof Error ? error : new Error();
+            const message = file && context ? `"${file}" in "${context}" from Image Minimizer:\n${cause.message}` : cause.message;
+            const ret = new compiler.webpack.WebpackError(message);
+            if (error instanceof Error) ret.error = error;
+            return ret;
+        };
+        const codec = shared_codecs[this.options.use];
+        if (!codec) compilation.errors.push(buildError(new Error(`Codec ${this.options.use} is not supported`)));
+        const opts = {
+            ...codec.defaultOptions,
+            ...this.options
+        };
+        const handleAsset = async (name)=>{
+            var _compilation_getAsset;
+            const info = null === (_compilation_getAsset = compilation.getAsset(name)) || void 0 === _compilation_getAsset ? void 0 : _compilation_getAsset.info;
+            const fileName = name.split('?')[0];
+            // 1. Skip double minimize assets from child compilation
+            // 2. Test file by options (e.g. test, include, exclude)
+            if ((null == info ? void 0 : info.minimized) || !matchObject(opts, fileName)) return;
+            const asset = compilation.getAsset(name);
+            if (!asset) return;
+            const { source: inputSource } = asset;
+            const eTag = cache.getLazyHashedEtag(inputSource);
+            const cacheItem = cache.getItemCache(name, eTag);
+            let result = await cacheItem.getPromise();
+            try {
+                if (!result) {
+                    const input = inputSource.source();
+                    const buf = await codec.handler(external_node_buffer_namespaceObject.Buffer.from(input), opts);
+                    result = {
+                        source: new RawSource(buf)
+                    };
+                    await cacheItem.storePromise(result);
+                }
+                compilation.updateAsset(name, result.source, {
+                    minimized: true
+                });
+            } catch (error) {
+                compilation.errors.push(buildError(error, name, compiler.context));
+            }
+        };
+        const promises = Object.keys(assets).map((name)=>handleAsset(name));
+        await Promise.all(promises);
     }
-    const opts = { ...codec.defaultOptions, ...this.options };
-    const handleAsset = async (name) => {
-      const info = compilation.getAsset(name)?.info;
-      const fileName = name.split("?")[0];
-      if (info?.minimized || !matchObject(opts, fileName)) {
-        return;
-      }
-      const asset = compilation.getAsset(name);
-      if (!asset) {
-        return;
-      }
-      const { source: inputSource } = asset;
-      const eTag = cache.getLazyHashedEtag(inputSource);
-      const cacheItem = cache.getItemCache(name, eTag);
-      let result = await cacheItem.getPromise();
-      try {
-        if (!result) {
-          const input = inputSource.source();
-          const buf = await codec.handler(import_node_buffer2.Buffer.from(input), opts);
-          result = { source: new RawSource(buf) };
-          await cacheItem.storePromise(result);
-        }
-        compilation.updateAsset(name, result.source, { minimized: true });
-      } catch (error) {
-        compilation.errors.push(buildError(error, name, compiler.context));
-      }
-    };
-    const promises = Object.keys(assets).map((name) => handleAsset(name));
-    await Promise.all(promises);
-  }
-  apply(compiler) {
-    const handleCompilation = (compilation) => {
-      compilation.hooks.processAssets.tapPromise(
-        {
-          name: this.name,
-          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
-          // @ts-expect-error unsupported by Rspack
-          additionalAssets: true
-        },
-        (assets) => this.optimize(compiler, compilation, assets)
-      );
-      compilation.hooks.statsPrinter.tap(this.name, (stats) => {
-        stats.hooks.print.for("asset.info.minimized").tap(
-          "@rsbuild/plugin-image-compress",
-          (minimized, { green, formatFlag }) => minimized && green && formatFlag ? green(formatFlag("minimized")) : ""
-        );
-      });
+    apply(compiler) {
+        const handleCompilation = (compilation)=>{
+            compilation.hooks.processAssets.tapPromise({
+                name: this.name,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+                // @ts-expect-error unsupported by Rspack
+                additionalAssets: true
+            }, (assets)=>this.optimize(compiler, compilation, assets));
+            compilation.hooks.statsPrinter.tap(this.name, (stats)=>{
+                stats.hooks.print.for('asset.info.minimized').tap('@rsbuild/plugin-image-compress', (minimized, { green, formatFlag })=>minimized && green && formatFlag ? green(formatFlag('minimized')) : '');
+            });
+        };
+        compiler.hooks.compilation.tap(this.name, handleCompilation);
+    }
+    constructor(options){
+        _define_property(this, "name", IMAGE_MINIMIZER_PLUGIN_NAME);
+        _define_property(this, "options", void 0);
+        this.options = options;
+    }
+}
+const withDefaultOptions = (opt)=>{
+    const options = 'string' == typeof opt ? {
+        use: opt
+    } : opt;
+    const { defaultOptions } = shared_codecs[options.use];
+    const ret = {
+        ...defaultOptions,
+        ...options
     };
-    compiler.hooks.compilation.tap(this.name, handleCompilation);
-  }
-};
-
-// src/shared/utils.ts
-var import_node_assert = __toESM(require("assert"), 1);
-var withDefaultOptions = (opt) => {
-  const options = typeof opt === "string" ? { use: opt } : opt;
-  const { defaultOptions } = codecs_default[options.use];
-  const ret = { ...defaultOptions, ...options };
-  (0, import_node_assert.default)("test" in ret);
-  return ret;
+    external_node_assert_default()('test' in ret);
+    return ret;
 };
-
-// src/index.ts
-var DEFAULT_OPTIONS = ["jpeg", "png", "ico"];
-var castOptions = (args) => {
-  const head = args[0];
-  if (Array.isArray(head)) {
-    return head;
-  }
-  const ret = [];
-  for (const arg of args) {
-    (0, import_node_assert2.default)(!Array.isArray(arg));
-    ret.push(arg);
-  }
-  return ret;
+const DEFAULT_OPTIONS = [
+    'jpeg',
+    'png',
+    'ico'
+];
+const castOptions = (args)=>{
+    const head = args[0];
+    // expect [['png', { use: 'jpeg' }]]
+    if (Array.isArray(head)) return head;
+    // expect ['png', { use: 'jpeg' }]
+    const ret = [];
+    for (const arg of args){
+        external_node_assert_default()(!Array.isArray(arg));
+        ret.push(arg);
+    }
+    return ret;
 };
-var normalizeOptions = (options) => {
-  const opts = options.length ? options : DEFAULT_OPTIONS;
-  const normalized = opts.map((opt) => withDefaultOptions(opt));
-  return normalized;
+const normalizeOptions = (options)=>{
+    const opts = options.length ? options : DEFAULT_OPTIONS;
+    const normalized = opts.map((opt)=>withDefaultOptions(opt));
+    return normalized;
 };
-var PLUGIN_IMAGE_COMPRESS_NAME = "rsbuild:image-compress";
-var pluginImageCompress = (...args) => ({
-  name: PLUGIN_IMAGE_COMPRESS_NAME,
-  setup(api) {
-    const opts = normalizeOptions(castOptions(args));
-    api.modifyBundlerChain((chain, { isDev }) => {
-      if (isDev) {
-        return;
-      }
-      chain.optimization.minimize(true);
-      for (const opt of opts) {
-        chain.optimization.minimizer(`image-compress-${opt.use}`).use(ImageMinimizerPlugin, [opt]);
-      }
+const PLUGIN_IMAGE_COMPRESS_NAME = 'rsbuild:image-compress';
+/** Options enable by default: {@link DEFAULT_OPTIONS} */ const pluginImageCompress = (...args)=>({
+        name: PLUGIN_IMAGE_COMPRESS_NAME,
+        setup (api) {
+            const opts = normalizeOptions(castOptions(args));
+            api.modifyBundlerChain((chain, { isDev })=>{
+                if (isDev) return;
+                chain.optimization.minimize(true);
+                for (const opt of opts)chain.optimization.minimizer(`image-compress-${opt.use}`).use(ImageMinimizerPlugin, [
+                    opt
+                ]);
+            });
+        }
     });
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DEFAULT_OPTIONS,
-  PLUGIN_IMAGE_COMPRESS_NAME,
-  pluginImageCompress
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
 });

package/dist/index.d.ts

@@ -1,38 +1,11 @@
-import { RsbuildPlugin } from '@rsbuild/core';
-import { JpegCompressOptions, PngQuantOptions, PNGLosslessOptions } from '@napi-rs/image';
-import { Config } from 'svgo';
-
-type OneOrMany<T> = T | T[];
-interface CodecBaseOptions {
-    jpeg: JpegCompressOptions;
-    png: PngQuantOptions;
-    pngLossless: PNGLosslessOptions;
-    ico: Record<string, unknown>;
-    svg: Config;
-}
-interface BaseCompressOptions<T extends Codecs> {
-    use: T;
-    test?: OneOrMany<RegExp>;
-    include?: OneOrMany<RegExp>;
-    exclude?: OneOrMany<RegExp>;
-}
-type FinalOptionCollection = {
-    [K in Codecs]: BaseCompressOptions<K> & CodecBaseOptions[K];
-};
-type Codecs = keyof CodecBaseOptions;
-type OptionCollection = {
-    [K in Codecs]: K | FinalOptionCollection[K];
-};
-type Options = OptionCollection[Codecs];
-
-type PluginImageCompressOptions = Options[];
-declare const DEFAULT_OPTIONS: Codecs[];
-interface IPluginImageCompress {
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { Codecs, Options } from './types.js';
+export type PluginImageCompressOptions = Options[];
+export declare const DEFAULT_OPTIONS: Codecs[];
+export interface IPluginImageCompress {
     (...options: Options[]): RsbuildPlugin;
     (options: Options[]): RsbuildPlugin;
 }
-declare const PLUGIN_IMAGE_COMPRESS_NAME = "rsbuild:image-compress";
+export declare const PLUGIN_IMAGE_COMPRESS_NAME = "rsbuild:image-compress";
 /** Options enable by default: {@link DEFAULT_OPTIONS} */
-declare const pluginImageCompress: IPluginImageCompress;
-
-export { DEFAULT_OPTIONS, type IPluginImageCompress, PLUGIN_IMAGE_COMPRESS_NAME, type PluginImageCompressOptions, pluginImageCompress };
+export declare const pluginImageCompress: IPluginImageCompress;

package/dist/index.js

@@ -1,194 +1,193 @@
-// src/index.ts
-import assert2 from "node:assert";
-
-// src/minimizer.ts
-import { Buffer as Buffer2 } from "node:buffer";
-
-// src/shared/codecs.ts
-import { Buffer } from "node:buffer";
-import {
-  Transformer,
-  compressJpeg,
-  losslessCompressPng,
-  pngQuantize
-} from "@napi-rs/image";
-import svgo from "svgo";
-var jpegCodec = {
-  handler(buf, options) {
-    return compressJpeg(buf, options);
-  },
-  defaultOptions: {
-    test: /\.(?:jpg|jpeg)$/
-  }
+import * as __WEBPACK_EXTERNAL_MODULE_node_assert__ from "node:assert";
+import * as __WEBPACK_EXTERNAL_MODULE_node_buffer__ from "node:buffer";
+import * as __WEBPACK_EXTERNAL_MODULE__napi_rs_image__ from "@napi-rs/image";
+import * as __WEBPACK_EXTERNAL_MODULE_svgo__ from "svgo";
+const jpegCodec = {
+    handler (buf, options) {
+        return (0, __WEBPACK_EXTERNAL_MODULE__napi_rs_image__.compressJpeg)(buf, options);
+    },
+    defaultOptions: {
+        test: /\.(?:jpg|jpeg)$/
+    }
 };
-var pngCodec = {
-  handler(buf, options) {
-    return pngQuantize(buf, options);
-  },
-  defaultOptions: {
-    test: /\.png$/
-  }
+const pngCodec = {
+    handler (buf, options) {
+        return (0, __WEBPACK_EXTERNAL_MODULE__napi_rs_image__.pngQuantize)(buf, options);
+    },
+    defaultOptions: {
+        test: /\.png$/
+    }
 };
-var pngLosslessCodec = {
-  handler(buf, options) {
-    return losslessCompressPng(buf, options);
-  },
-  defaultOptions: {
-    test: /\.png$/
-  }
+const pngLosslessCodec = {
+    handler (buf, options) {
+        return (0, __WEBPACK_EXTERNAL_MODULE__napi_rs_image__.losslessCompressPng)(buf, options);
+    },
+    defaultOptions: {
+        test: /\.png$/
+    }
 };
-var icoCodec = {
-  handler(buf) {
-    return new Transformer(buf).ico();
-  },
-  defaultOptions: {
-    test: /\.(?:ico|icon)$/
-  }
+const icoCodec = {
+    handler (buf) {
+        return new __WEBPACK_EXTERNAL_MODULE__napi_rs_image__.Transformer(buf).ico();
+    },
+    defaultOptions: {
+        test: /\.(?:ico|icon)$/
+    }
 };
-var svgCodec = {
-  async handler(buf, options) {
-    const result = svgo.optimize(buf.toString(), options);
-    return Buffer.from(result.data);
-  },
-  defaultOptions: {
-    test: /\.svg$/
-  }
+const avifCodec = {
+    handler (buf, options) {
+        return new __WEBPACK_EXTERNAL_MODULE__napi_rs_image__.Transformer(buf).avif(options);
+    },
+    defaultOptions: {
+        test: /\.avif$/
+    }
 };
-var codecs = {
-  jpeg: jpegCodec,
-  png: pngCodec,
-  pngLossless: pngLosslessCodec,
-  ico: icoCodec,
-  svg: svgCodec
+const svgCodec = {
+    async handler (buf, options) {
+        const result = __WEBPACK_EXTERNAL_MODULE_svgo__["default"].optimize(buf.toString(), options);
+        return __WEBPACK_EXTERNAL_MODULE_node_buffer__.Buffer.from(result.data);
+    },
+    defaultOptions: {
+        test: /\.svg$/
+    }
 };
-var codecs_default = codecs;
-
-// src/minimizer.ts
-var IMAGE_MINIMIZER_PLUGIN_NAME = "@rsbuild/plugin-image-compress/minimizer";
-var ImageMinimizerPlugin = class {
-  constructor(options) {
-    this.name = IMAGE_MINIMIZER_PLUGIN_NAME;
-    this.options = options;
-  }
-  async optimize(compiler, compilation, assets) {
-    const cache = compilation.getCache(IMAGE_MINIMIZER_PLUGIN_NAME);
-    const { RawSource } = compiler.webpack.sources;
-    const { matchObject } = compiler.webpack.ModuleFilenameHelpers;
-    const buildError = (error, file, context) => {
-      const cause = error instanceof Error ? error : new Error();
-      const message = file && context ? `"${file}" in "${context}" from Image Minimizer:
-${cause.message}` : cause.message;
-      const ret = new compiler.webpack.WebpackError(message);
-      if (error instanceof Error) {
-        ret.error = error;
-      }
-      return ret;
-    };
-    const codec = codecs_default[this.options.use];
-    if (!codec) {
-      compilation.errors.push(
-        buildError(new Error(`Codec ${this.options.use} is not supported`))
-      );
+// biome-ignore lint/suspicious/noExplicitAny:allow any
+const codecs = {
+    jpeg: jpegCodec,
+    png: pngCodec,
+    pngLossless: pngLosslessCodec,
+    ico: icoCodec,
+    svg: svgCodec,
+    avif: avifCodec
+};
+/* ESM default export */ const shared_codecs = codecs;
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const IMAGE_MINIMIZER_PLUGIN_NAME = '@rsbuild/plugin-image-compress/minimizer';
+class ImageMinimizerPlugin {
+    async optimize(compiler, compilation, assets) {
+        const cache = compilation.getCache(IMAGE_MINIMIZER_PLUGIN_NAME);
+        const { RawSource } = compiler.webpack.sources;
+        const { matchObject } = compiler.webpack.ModuleFilenameHelpers;
+        const buildError = (error, file, context)=>{
+            const cause = error instanceof Error ? error : new Error();
+            const message = file && context ? `"${file}" in "${context}" from Image Minimizer:\n${cause.message}` : cause.message;
+            const ret = new compiler.webpack.WebpackError(message);
+            if (error instanceof Error) ret.error = error;
+            return ret;
+        };
+        const codec = shared_codecs[this.options.use];
+        if (!codec) compilation.errors.push(buildError(new Error(`Codec ${this.options.use} is not supported`)));
+        const opts = {
+            ...codec.defaultOptions,
+            ...this.options
+        };
+        const handleAsset = async (name)=>{
+            var _compilation_getAsset;
+            const info = null === (_compilation_getAsset = compilation.getAsset(name)) || void 0 === _compilation_getAsset ? void 0 : _compilation_getAsset.info;
+            const fileName = name.split('?')[0];
+            // 1. Skip double minimize assets from child compilation
+            // 2. Test file by options (e.g. test, include, exclude)
+            if ((null == info ? void 0 : info.minimized) || !matchObject(opts, fileName)) return;
+            const asset = compilation.getAsset(name);
+            if (!asset) return;
+            const { source: inputSource } = asset;
+            const eTag = cache.getLazyHashedEtag(inputSource);
+            const cacheItem = cache.getItemCache(name, eTag);
+            let result = await cacheItem.getPromise();
+            try {
+                if (!result) {
+                    const input = inputSource.source();
+                    const buf = await codec.handler(__WEBPACK_EXTERNAL_MODULE_node_buffer__.Buffer.from(input), opts);
+                    result = {
+                        source: new RawSource(buf)
+                    };
+                    await cacheItem.storePromise(result);
+                }
+                compilation.updateAsset(name, result.source, {
+                    minimized: true
+                });
+            } catch (error) {
+                compilation.errors.push(buildError(error, name, compiler.context));
+            }
+        };
+        const promises = Object.keys(assets).map((name)=>handleAsset(name));
+        await Promise.all(promises);
     }
-    const opts = { ...codec.defaultOptions, ...this.options };
-    const handleAsset = async (name) => {
-      const info = compilation.getAsset(name)?.info;
-      const fileName = name.split("?")[0];
-      if (info?.minimized || !matchObject(opts, fileName)) {
-        return;
-      }
-      const asset = compilation.getAsset(name);
-      if (!asset) {
-        return;
-      }
-      const { source: inputSource } = asset;
-      const eTag = cache.getLazyHashedEtag(inputSource);
-      const cacheItem = cache.getItemCache(name, eTag);
-      let result = await cacheItem.getPromise();
-      try {
-        if (!result) {
-          const input = inputSource.source();
-          const buf = await codec.handler(Buffer2.from(input), opts);
-          result = { source: new RawSource(buf) };
-          await cacheItem.storePromise(result);
-        }
-        compilation.updateAsset(name, result.source, { minimized: true });
-      } catch (error) {
-        compilation.errors.push(buildError(error, name, compiler.context));
-      }
-    };
-    const promises = Object.keys(assets).map((name) => handleAsset(name));
-    await Promise.all(promises);
-  }
-  apply(compiler) {
-    const handleCompilation = (compilation) => {
-      compilation.hooks.processAssets.tapPromise(
-        {
-          name: this.name,
-          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
-          // @ts-expect-error unsupported by Rspack
-          additionalAssets: true
-        },
-        (assets) => this.optimize(compiler, compilation, assets)
-      );
-      compilation.hooks.statsPrinter.tap(this.name, (stats) => {
-        stats.hooks.print.for("asset.info.minimized").tap(
-          "@rsbuild/plugin-image-compress",
-          (minimized, { green, formatFlag }) => minimized && green && formatFlag ? green(formatFlag("minimized")) : ""
-        );
-      });
+    apply(compiler) {
+        const handleCompilation = (compilation)=>{
+            compilation.hooks.processAssets.tapPromise({
+                name: this.name,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+                // @ts-expect-error unsupported by Rspack
+                additionalAssets: true
+            }, (assets)=>this.optimize(compiler, compilation, assets));
+            compilation.hooks.statsPrinter.tap(this.name, (stats)=>{
+                stats.hooks.print.for('asset.info.minimized').tap('@rsbuild/plugin-image-compress', (minimized, { green, formatFlag })=>minimized && green && formatFlag ? green(formatFlag('minimized')) : '');
+            });
+        };
+        compiler.hooks.compilation.tap(this.name, handleCompilation);
+    }
+    constructor(options){
+        _define_property(this, "name", IMAGE_MINIMIZER_PLUGIN_NAME);
+        _define_property(this, "options", void 0);
+        this.options = options;
+    }
+}
+const withDefaultOptions = (opt)=>{
+    const options = 'string' == typeof opt ? {
+        use: opt
+    } : opt;
+    const { defaultOptions } = shared_codecs[options.use];
+    const ret = {
+        ...defaultOptions,
+        ...options
     };
-    compiler.hooks.compilation.tap(this.name, handleCompilation);
-  }
+    (0, __WEBPACK_EXTERNAL_MODULE_node_assert__["default"])('test' in ret);
+    return ret;
 };
-
-// src/shared/utils.ts
-import assert from "node:assert";
-var withDefaultOptions = (opt) => {
-  const options = typeof opt === "string" ? { use: opt } : opt;
-  const { defaultOptions } = codecs_default[options.use];
-  const ret = { ...defaultOptions, ...options };
-  assert("test" in ret);
-  return ret;
-};
-
-// src/index.ts
-var DEFAULT_OPTIONS = ["jpeg", "png", "ico"];
-var castOptions = (args) => {
-  const head = args[0];
-  if (Array.isArray(head)) {
-    return head;
-  }
-  const ret = [];
-  for (const arg of args) {
-    assert2(!Array.isArray(arg));
-    ret.push(arg);
-  }
-  return ret;
+const DEFAULT_OPTIONS = [
+    'jpeg',
+    'png',
+    'ico'
+];
+const castOptions = (args)=>{
+    const head = args[0];
+    // expect [['png', { use: 'jpeg' }]]
+    if (Array.isArray(head)) return head;
+    // expect ['png', { use: 'jpeg' }]
+    const ret = [];
+    for (const arg of args){
+        (0, __WEBPACK_EXTERNAL_MODULE_node_assert__["default"])(!Array.isArray(arg));
+        ret.push(arg);
+    }
+    return ret;
 };
-var normalizeOptions = (options) => {
-  const opts = options.length ? options : DEFAULT_OPTIONS;
-  const normalized = opts.map((opt) => withDefaultOptions(opt));
-  return normalized;
+const normalizeOptions = (options)=>{
+    const opts = options.length ? options : DEFAULT_OPTIONS;
+    const normalized = opts.map((opt)=>withDefaultOptions(opt));
+    return normalized;
 };
-var PLUGIN_IMAGE_COMPRESS_NAME = "rsbuild:image-compress";
-var pluginImageCompress = (...args) => ({
-  name: PLUGIN_IMAGE_COMPRESS_NAME,
-  setup(api) {
-    const opts = normalizeOptions(castOptions(args));
-    api.modifyBundlerChain((chain, { isDev }) => {
-      if (isDev) {
-        return;
-      }
-      chain.optimization.minimize(true);
-      for (const opt of opts) {
-        chain.optimization.minimizer(`image-compress-${opt.use}`).use(ImageMinimizerPlugin, [opt]);
-      }
+const PLUGIN_IMAGE_COMPRESS_NAME = 'rsbuild:image-compress';
+/** Options enable by default: {@link DEFAULT_OPTIONS} */ const pluginImageCompress = (...args)=>({
+        name: PLUGIN_IMAGE_COMPRESS_NAME,
+        setup (api) {
+            const opts = normalizeOptions(castOptions(args));
+            api.modifyBundlerChain((chain, { isDev })=>{
+                if (isDev) return;
+                chain.optimization.minimize(true);
+                for (const opt of opts)chain.optimization.minimizer(`image-compress-${opt.use}`).use(ImageMinimizerPlugin, [
+                    opt
+                ]);
+            });
+        }
     });
-  }
-});
-export {
-  DEFAULT_OPTIONS,
-  PLUGIN_IMAGE_COMPRESS_NAME,
-  pluginImageCompress
-};
+export { DEFAULT_OPTIONS, PLUGIN_IMAGE_COMPRESS_NAME, pluginImageCompress };

package/dist/minimizer.d.ts

@@ -0,0 +1,13 @@
+import type { Rspack } from '@rsbuild/core';
+import type { FinalOptions } from './types.js';
+export declare const IMAGE_MINIMIZER_PLUGIN_NAME: "@rsbuild/plugin-image-compress/minimizer";
+export interface MinimizedResult {
+    source: Rspack.sources.RawSource;
+}
+export declare class ImageMinimizerPlugin {
+    name: string;
+    options: FinalOptions;
+    constructor(options: FinalOptions);
+    optimize(compiler: Rspack.Compiler, compilation: Rspack.Compilation, assets: Record<string, Rspack.sources.Source>): Promise<void>;
+    apply(compiler: Rspack.Compiler): void;
+}

package/dist/shared/codecs.d.ts

@@ -0,0 +1,9 @@
+import type { Codec, Codecs } from '../types.js';
+export declare const jpegCodec: Codec<'jpeg'>;
+export declare const pngCodec: Codec<'png'>;
+export declare const pngLosslessCodec: Codec<'pngLossless'>;
+export declare const icoCodec: Codec<'ico'>;
+export declare const avifCodec: Codec<'avif'>;
+export declare const svgCodec: Codec<'svg'>;
+declare const codecs: Record<Codecs, Codec<any>>;
+export default codecs;

package/dist/shared/utils.d.ts

@@ -0,0 +1,2 @@
+import type { FinalOptions, Options } from '../types.js';
+export declare const withDefaultOptions: (opt: Options) => FinalOptions;

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+import type { Buffer } from 'node:buffer';
+import type { AvifConfig, JpegCompressOptions, PNGLosslessOptions, PngQuantOptions } from '@napi-rs/image';
+import type { Config as SvgoConfig } from 'svgo';
+export type OneOrMany<T> = T | T[];
+export interface WebpTransformOptions {
+    quality?: number;
+}
+export interface CodecBaseOptions {
+    jpeg: JpegCompressOptions;
+    png: PngQuantOptions;
+    pngLossless: PNGLosslessOptions;
+    ico: Record<string, unknown>;
+    svg: SvgoConfig;
+    avif: AvifConfig;
+}
+export interface BaseCompressOptions<T extends Codecs> {
+    use: T;
+    test?: OneOrMany<RegExp>;
+    include?: OneOrMany<RegExp>;
+    exclude?: OneOrMany<RegExp>;
+}
+export type FinalOptionCollection = {
+    [K in Codecs]: BaseCompressOptions<K> & CodecBaseOptions[K];
+};
+export type FinalOptions = FinalOptionCollection[Codecs];
+export interface Codec<T extends Codecs> {
+    handler: (buf: Buffer, options: CodecBaseOptions[T]) => Promise<Buffer>;
+    defaultOptions: Omit<FinalOptionCollection[T], 'use'>;
+}
+export type Codecs = keyof CodecBaseOptions;
+export type OptionCollection = {
+    [K in Codecs]: K | FinalOptionCollection[K];
+};
+export type Options = OptionCollection[Codecs];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/plugin-image-compress",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "repository": "https://github.com/rspack-contrib/rsbuild-plugin-image-compress",
   "license": "MIT",
   "type": "module",
@@ -14,9 +14,16 @@
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "lint": "biome check .",
+    "lint:write": "biome check . --write",
+    "prepare": "simple-git-hooks && npm run build",
+    "test": "playwright test",
+    "bump": "npx bumpp"
+  },
   "simple-git-hooks": {
     "pre-commit": "npx nano-staged"
   },
@@ -30,33 +37,27 @@
     "svgo": "^3.3.2"
   },
   "devDependencies": {
-    "@biomejs/biome": "^1.8.3",
-    "@playwright/test": "^1.45.3",
-    "@rsbuild/core": "1.0.0-alpha.9",
-    "@types/node": "^20.14.13",
+    "@biomejs/biome": "^1.9.4",
+    "@playwright/test": "^1.49.0",
+    "@rsbuild/core": "1.1.6",
+    "@rslib/core": "^0.1.1",
+    "@types/node": "^22.10.1",
     "nano-staged": "^0.8.0",
-    "playwright": "^1.45.3",
+    "playwright": "^1.49.0",
     "simple-git-hooks": "^2.11.1",
-    "tsup": "^8.2.3",
-    "typescript": "^5.5.4"
+    "typescript": "^5.7.2"
   },
   "peerDependencies": {
-    "@rsbuild/core": "1.x || ^1.0.1-beta.0"
+    "@rsbuild/core": "1.x"
   },
   "peerDependenciesMeta": {
     "@rsbuild/core": {
       "optional": true
     }
   },
+  "packageManager": "pnpm@9.14.4",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "lint": "biome check .",
-    "lint:write": "biome check . --write",
-    "test": "playwright test"
   }
-}
+}

package/dist/index.d.cts

@@ -1,38 +0,0 @@
-import { RsbuildPlugin } from '@rsbuild/core';
-import { JpegCompressOptions, PngQuantOptions, PNGLosslessOptions } from '@napi-rs/image';
-import { Config } from 'svgo';
-
-type OneOrMany<T> = T | T[];
-interface CodecBaseOptions {
-    jpeg: JpegCompressOptions;
-    png: PngQuantOptions;
-    pngLossless: PNGLosslessOptions;
-    ico: Record<string, unknown>;
-    svg: Config;
-}
-interface BaseCompressOptions<T extends Codecs> {
-    use: T;
-    test?: OneOrMany<RegExp>;
-    include?: OneOrMany<RegExp>;
-    exclude?: OneOrMany<RegExp>;
-}
-type FinalOptionCollection = {
-    [K in Codecs]: BaseCompressOptions<K> & CodecBaseOptions[K];
-};
-type Codecs = keyof CodecBaseOptions;
-type OptionCollection = {
-    [K in Codecs]: K | FinalOptionCollection[K];
-};
-type Options = OptionCollection[Codecs];
-
-type PluginImageCompressOptions = Options[];
-declare const DEFAULT_OPTIONS: Codecs[];
-interface IPluginImageCompress {
-    (...options: Options[]): RsbuildPlugin;
-    (options: Options[]): RsbuildPlugin;
-}
-declare const PLUGIN_IMAGE_COMPRESS_NAME = "rsbuild:image-compress";
-/** Options enable by default: {@link DEFAULT_OPTIONS} */
-declare const pluginImageCompress: IPluginImageCompress;
-
-export { DEFAULT_OPTIONS, type IPluginImageCompress, PLUGIN_IMAGE_COMPRESS_NAME, type PluginImageCompressOptions, pluginImageCompress };