@rsbuild/plugin-image-compress 0.0.0-nightly-20231017160746

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Bytedance, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+<p align="center">
+  <a href="https://rsbuild.dev" target="blank"><img src="https://github.com/web-infra-dev/rsbuild/assets/7237365/84abc13e-b620-468f-a90b-dbf28e7e9427" alt="Rsbuild Logo" /></a>
+</p>
+
+# Rsbuild
+
+Unleash the power of Rspack with the out-of-the-box build tool.
+
+## Getting Started
+
+Please follow [Quick Start](https://rsbuild.dev/guides/get-started/quick-start) to get started with Rsbuild.
+
+## Documentation
+
+- [English Documentation](https://rsbuild.dev/)
+- [中文文档](https://rsbuild.dev/zh)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/rsbuild/blob/main/CONTRIBUTING.md).
+
+## License
+
+Rsbuild is [MIT licensed](https://github.com/web-infra-dev/rsbuild/blob/main/LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { BuilderPlugin } from '@modern-js/builder-webpack-provider/types';
+import { Codecs, Options } from './types';
+export type PluginImageCompressOptions = Options[];
+export declare const DEFAULT_OPTIONS: Codecs[];
+export interface IPluginImageCompress {
+  (...options: Options[]): BuilderPlugin;
+  (options: Options[]): BuilderPlugin;
+}
+/** Options enable by default: {@link DEFAULT_OPTIONS} */
+export declare const builderPluginImageCompress: IPluginImageCompress;

package/dist/index.js

@@ -0,0 +1,75 @@
+"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);
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
+  builderPluginImageCompress: () => builderPluginImageCompress
+});
+module.exports = __toCommonJS(src_exports);
+var import_assert = __toESM(require("assert"));
+var import_minimizer = require("./minimizer");
+var import_utils = require("./shared/utils");
+const DEFAULT_OPTIONS = ["jpeg", "png", "ico"];
+const castOptions = (args) => {
+  const head = args[0];
+  if (Array.isArray(head)) {
+    return head;
+  }
+  const ret = [];
+  for (const arg of args) {
+    (0, import_assert.default)(!Array.isArray(arg));
+    ret.push(arg);
+  }
+  return ret;
+};
+const normalizeOptions = (options) => {
+  const opts = options.length ? options : DEFAULT_OPTIONS;
+  const normalized = opts.map((opt) => (0, import_utils.withDefaultOptions)(opt));
+  return normalized;
+};
+const builderPluginImageCompress = (...args) => ({
+  name: "builder-plugin-image-compress",
+  setup(api) {
+    const opts = normalizeOptions(castOptions(args));
+    api.modifyBundlerChain((chain, { env }) => {
+      if (env !== "production") {
+        return;
+      }
+      chain.optimization.minimize(true);
+      for (const opt of opts) {
+        chain.optimization.minimizer(`image-compress-${opt.use}`).use(import_minimizer.ModernJsImageMinimizerPlugin, [opt]);
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_OPTIONS,
+  builderPluginImageCompress
+});

package/dist/minimizer.d.ts

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

package/dist/minimizer.js

@@ -0,0 +1,111 @@
+"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);
+var minimizer_exports = {};
+__export(minimizer_exports, {
+  MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME: () => MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME,
+  ModernJsImageMinimizerPlugin: () => ModernJsImageMinimizerPlugin
+});
+module.exports = __toCommonJS(minimizer_exports);
+var import_buffer = require("buffer");
+var import_codecs = __toESM(require("./shared/codecs"));
+const MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME = "@rsbuild/plugin-image-compress/minimizer";
+class ModernJsImageMinimizerPlugin {
+  constructor(options) {
+    this.name = MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME;
+    this.options = options;
+  }
+  async optimize(compiler, compilation, assets) {
+    const cache = compilation.getCache(MODERN_JS_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 Modern.js Image Minimizer:
+${cause.message}` : cause.message;
+      const ret = new compiler.webpack.WebpackError(message);
+      error instanceof Error && (ret.error = error);
+      return ret;
+    };
+    const codec = import_codecs.default[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 _a;
+      const info = (_a = compilation.getAsset(name)) == null ? void 0 : _a.info;
+      if ((info == null ? void 0 : info.minimized) || !matchObject(opts, name)) {
+        return;
+      }
+      const { source: inputSource } = compilation.getAsset(name);
+      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_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);
+  }
+  apply(compiler) {
+    const handleCompilation = (compilation) => {
+      compilation.hooks.processAssets.tapPromise(
+        {
+          name: this.name,
+          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+          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);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MODERN_JS_IMAGE_MINIMIZER_PLUGIN_NAME,
+  ModernJsImageMinimizerPlugin
+});

package/dist/shared/codecs.d.ts

@@ -0,0 +1,8 @@
+import { Codec, Codecs } from '../types';
+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 svgCodec: Codec<'svg'>;
+declare const codecs: Record<Codecs, Codec<any>>;
+export default codecs;

package/dist/shared/codecs.js

@@ -0,0 +1,98 @@
+"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);
+var codecs_exports = {};
+__export(codecs_exports, {
+  default: () => codecs_default,
+  icoCodec: () => icoCodec,
+  jpegCodec: () => jpegCodec,
+  pngCodec: () => pngCodec,
+  pngLosslessCodec: () => pngLosslessCodec,
+  svgCodec: () => svgCodec
+});
+module.exports = __toCommonJS(codecs_exports);
+var import_buffer = require("buffer");
+var import_image = require("@napi-rs/image");
+var import_svgo = __toESM(require("svgo"));
+const jpegCodec = {
+  handler(buf, options) {
+    return (0, import_image.compressJpeg)(buf, options);
+  },
+  defaultOptions: {
+    test: /\.(jpg|jpeg)$/
+  }
+};
+const pngCodec = {
+  handler(buf, options) {
+    return (0, import_image.pngQuantize)(buf, options);
+  },
+  defaultOptions: {
+    test: /\.png$/
+  }
+};
+const pngLosslessCodec = {
+  handler(buf, options) {
+    return (0, import_image.losslessCompressPng)(buf, options);
+  },
+  defaultOptions: {
+    test: /\.png$/
+  }
+};
+const icoCodec = {
+  handler(buf) {
+    return new import_image.Transformer(buf).ico();
+  },
+  defaultOptions: {
+    test: /\.(ico|icon)$/
+  }
+};
+const svgCodec = {
+  async handler(buf, options) {
+    const result = import_svgo.default.optimize(buf.toString(), options);
+    return import_buffer.Buffer.from(result.data);
+  },
+  defaultOptions: {
+    test: /\.svg$/
+  }
+};
+const codecs = {
+  jpeg: jpegCodec,
+  png: pngCodec,
+  pngLossless: pngLosslessCodec,
+  ico: icoCodec,
+  svg: svgCodec
+};
+var codecs_default = codecs;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  icoCodec,
+  jpegCodec,
+  pngCodec,
+  pngLosslessCodec,
+  svgCodec
+});

package/dist/shared/utils.d.ts

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

package/dist/shared/utils.js

@@ -0,0 +1,47 @@
+"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);
+var utils_exports = {};
+__export(utils_exports, {
+  withDefaultOptions: () => withDefaultOptions
+});
+module.exports = __toCommonJS(utils_exports);
+var import_assert = __toESM(require("assert"));
+var import_lodash = __toESM(require("@modern-js/utils/lodash"));
+var import_codecs = __toESM(require("./codecs"));
+const withDefaultOptions = (opt) => {
+  const options = import_lodash.default.isString(opt) ? { use: opt } : opt;
+  const { defaultOptions } = import_codecs.default[options.use];
+  const ret = { ...defaultOptions, ...options };
+  (0, import_assert.default)("test" in ret);
+  return ret;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withDefaultOptions
+});

package/dist/types/index.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import type { Buffer } from 'buffer';
+import { JpegCompressOptions, PNGLosslessOptions, PngQuantOptions } from '@napi-rs/image';
+import type { Config as SvgoConfig } from 'svgo';
+export type ArrayOrNot<T> = T | T[];
+export interface WebpTransformOptions {
+  quality?: number;
+}
+export interface CodecBaseOptions {
+  jpeg: JpegCompressOptions;
+  png: PngQuantOptions;
+  pngLossless: PNGLosslessOptions;
+  ico: {};
+  svg: SvgoConfig;
+}
+export interface BaseCompressOptions<T extends Codecs> {
+  use: T;
+  test?: ArrayOrNot<RegExp>;
+  include?: ArrayOrNot<RegExp>;
+  exclude?: ArrayOrNot<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/dist/types/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@rsbuild/plugin-image-compress",
+  "description": "Image compress plugin for modern-js/web-builder",
+  "homepage": "https://rsbuild.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/web-infra-dev/rsbuild",
+    "directory": "packages/plugin-image-compress"
+  },
+  "license": "MIT",
+  "version": "0.0.0-nightly-20231017160746",
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modern-js/utils": "^2.36.0",
+    "@napi-rs/image": "^1.7.0",
+    "svgo": "^3.0.2"
+  },
+  "devDependencies": {
+    "@modern-js/builder-webpack-provider": "^2.36.0",
+    "@types/node": "^16",
+    "typescript": "^5",
+    "webpack": "^5.88.1"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "dev": "modern build --watch",
+    "build": "modern build"
+  }
+}