Minifier CLI Documentation

Minifier CLI is a powerful node command-line tool designed to minify JavaScript, CSS, and HTML files recursively within a specified directory or for individual files. It leverages popular minification libraries like Terser, cssnano, and html-minifier-terser to achieve optimal file size reduction.

Table of Contents

• Installation
• Usage
  • Basic Usage
  • Minifying Files and Directories
  • Options
  • Ignoring Files and Directories
• Configuration Options Reference
• Ignore Patterns Reference
• Examples

Installation

To install Minifier CLI globally on your system, open your terminal or command prompt and run the following command:

npm install -g minifier-cli
#or
yarn add -g minifier-cli

This will make the minifier command available system-wide.

Usage

The minifier command follows a simple structure:

minifier <path> [options]

Basic Usage

You must provide a <path> argument, which can be either a file or a directory.

• Minify the current directory:

  minifier .

• Minify a specific directory:

  minifier my_project/

• Minify a single file:

  minifier public/index.html
  # or
  minifier src/app.js
  # or
  minifier assets/styles.css

Minifying Files and Directories

When you specify a directory, minifier will recursively traverse all subdirectories and minify .js, .css, and .html files it finds. When you specify a file, only that specific file will be processed.

Options

You can control the minification process using various options. These options are placed after the <path> argument.

Ignoring Files and Directories

Minifier CLI provides flexible ways to ignore specific files or directories from the minification process, similar to .gitignore.

1. Using the --ignore Flag

Use the -i or --ignore flag followed by a comma-separated list of minimatch patterns. You can use this flag multiple times.

• Ignore a specific file:

  minifier . -i "index.html"

• Ignore a specific directory:

  minifier my_project/ --ignore "images/"

• Ignore all files of a certain type in the current directory (non-recursive):

  minifier . -i "*.map"

• Ignore all files of a certain type recursively:

  minifier . -i "**/*.js"

  Note: A single * matches within a single path segment. Use **/*.ext to ignore files recursively across all subdirectories.

• Ignore multiple patterns:

minifier my_project/ -i "images/,dist/css/"

2. Using an .minifierignore File

You can create a file named .minifierignore in the base directory you are minifying (or specify a custom path) to list patterns of files/directories to ignore. This works just like .gitignore.

• Example .minifierignore content:

  # Ignore specific files
  dist/index.html
  src/config.js
  # Ignore entire directories
     
  images/
  temp_files/
     
  # Ignore all files of a specific type recursively
  **/*.map
  node_modules/

• Usage with default .minifierignore: Place the .minifierignore file in the same directory as your project root, then run:

  minifier my_project/

  or if you're in the project root:

  minifier .

3. Using a Custom Ignore File Path

Specify a custom path to your ignore file using the --ignore-path flag:

minifier my_project/ --ignore-path config/.custom_ignore_rules

Note: Patterns provided via the --ignore flag will be combined with patterns found in the .minifierignore file (if present).

Configuration Options Reference

The following table details all available options for customizing the minification process: | Short Flag | Long Flag | Description | Default | Disable Flag (for defaults that are true) | |---|---|---|---|---| | -V | --version | Output the version number. | N/A | N/A | | -h | --help | Display help for the command. | N/A | N/A | | -d | --drop-console | Drop console.log statements in JavaScript files. | false | N/A | | -m | --mangle | Mangle variable and function names in JavaScript files. | true | --no-mangle | | | --collapse-whitespace | Collapse whitespace in HTML files. | true | --no-collapse-whitespace | | | --remove-comments | Remove comments in HTML files. | true | --no-remove-comments | | | --remove-redundant-attributes | Remove redundant attributes in HTML files. | true | --no-remove-redundant-attributes | | | --use-short-doctype | Replace doctype with short HTML5 doctype ( <!DOCTYPE html>) in HTML files. | true | --no-use-short-doctype | | | --minify-css | Minify CSS in <style> tags within HTML files. | true | --no-minify-css | | | --minify-js | Minify JavaScript in <script> tags within HTML files. | true | --no-minify-js | | -i | --ignore <paths> | Comma-separated list of minimatch patterns (files/directories) to ignore. Can be specified multiple times. | [] | N/A | | | --ignore-path <file> | Path to a custom .minifierignore file. Looks for .minifierignore in the target path's directory by default. | N/A | N/A | | -s | --source-map | create a source map file for your minified file (css, js) to simplify brower debuging | false | N/A | | | --source-map-dir <path> | Specify where to save your map files, If don't used minifier will save the the map file to where the minified file is saved | (Save where minified file is saved) | N/A | | -o <path> | --output-dir <path> | Specify an output directory for minified files, relative or absolute. Can include a renaming pattern (e.g., "**/*.min.js"). | overwrite | N/A | | | --dry-run | Simulate minification without writing any files, just to see what files would be minified | false | N/A | | | --no-verbose | Disable verbose logging for detailed output. | true | N/A |

Ignore Patterns Reference

Minifier CLI uses minimatch for pattern matching, which is the same library used by Git.

| Pattern | Description | |---|---| | foo.txt | Matches foo.txt in the base directory. | | dir/ | Matches the directory dir and all its contents (e.g., dir/file.txt, dir/subdir/another.js). | | /foo.txt | Matches foo.txt only in the base directory, not in subdirectories (e.g., will not match subdir/foo.txt). | | .js | Matches all files ending with .js in the base directory (e.g., app.js), but not in subdirectories (e.g., will not match src/utils.js). | | **/.js | Matches all files ending with .js in the base directory and all its subdirectories (e.g., app.js, src/utils.js, lib/components/button.js). This is the most common pattern for recursive file type ignoring. | | foo/** | Matches everything inside the foo directory. Equivalent to foo/. | | foo/**/bar.js | Matches bar.js in foo/bar.js, foo/baz/bar.js, foo/baz/qux/bar.js, etc. | | !pattern | Negates a pattern. If a file matches a previous ignore pattern but also matches a later negated pattern, it will not be ignored. (e.g., build/, !build/index.html would ignore the build directory except for build/index.html). | | # comment | Lines starting with # in .minifierignore are treated as comments and ignored. | | (empty) | Empty lines in .minifierignore are ignored. |

Examples

• Minify the entire public directory, drop console.log statements, and keep comments in HTML:

  minifier public/ -d --no-remove-comments

• Minify the current directory, ignore the node_modules and dist folders, and all .map files recursively:

  minifier . -i "node_modules/,dist/,**/*.map"

• Process only index.html and main.js from the build directory, disabling JS mangling and CSS minification within HTML:

  minifier build/index.html build/main.js --no-mangle --no-minify-css

  (Note: To process multiple specific files, you would typically run the command for each file or use a script. The minifier <path> argument expects a single file or directory as its primary target.)

• Minify your src directory using a custom ignore file located at config/my_project.ignore:

  minifier src/ --ignore-path config/my_project.ignore

• Minify all JavaScript files in the current directory, but specifically don't drop console statements:

  minifier . --no-drop-console # Although default, explicitly shows how to negate if it were true

  (Note: The --no- prefix only applies to boolean options that default to true.)

  • Minify build directory, dropping console logs and disabling JS variable mangling:

  minifier build --drop-console --no-mangle

  • Minify public directory, but keep all comments and whitespace in HTML:

  minifier public --no-remove-comments --no-collapse-whitespace

❓ Help & Version

To see the full list of commands and options directly from your terminal: minifier --help

To check the installed version:

minifier --version

🤝 Contributing

Contributions are welcome! If you find a bug or have a feature request, please open an issue on the GitHub repository. Here

📄 License

This project is licensed under the MIT License.