CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-minify

Minifier of js, css, html and img files with CLI and programmatic interfaces

—

Pending
Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

cli-interface.mddocs/

CLI Interface

Comprehensive command-line interface for minifying web assets with support for file processing, stdin/stdout operations, and flexible configuration options.

Capabilities

CLI Command Structure

The minify CLI provides multiple operation modes for different use cases.

# File processing
minify [files...]

# Stdin processing with format specification
minify --js    # Process stdin as JavaScript
minify --css   # Process stdin as CSS
minify --html  # Process stdin as HTML
minify --auto  # Auto-detect stdin format

# Information commands
minify --help     # Display help information
minify --version  # Display version information

Basic Usage Examples:

# Minify a single file
minify script.js

# Minify multiple files
minify app.js styles.css index.html

# Minify with output redirection
minify script.js > script.min.js

# Process stdin with format detection
cat source.js | minify --js

# Auto-detect format from stdin
echo "body { color: red; }" | minify --auto

File Processing Mode

Multiple File Processing

Process multiple files simultaneously with automatic format detection based on file extensions.

# Syntax
minify file1.js file2.css file3.html [options]

# Supported extensions
# .js  - JavaScript files
# .css - CSS files  
# .html - HTML files

File Processing Examples:

# Single file minification
minify app.js
# Output: Minified JavaScript content to stdout

# Multiple mixed files
minify src/main.js assets/style.css templates/index.html
# Output: Each file's minified content in sequence

# Wildcard file selection
minify assets/*.css
# Output: All CSS files in assets/ directory minified

# Complex file patterns
minify src/**/*.js dist/*.css
# Output: All JS files recursively from src/ and CSS from dist/

File Output Handling

The CLI outputs minified content to stdout by default:

# Direct console output
minify script.js
# Displays minified content

# Save to new file
minify script.js > script.min.js

# Append to existing file
minify additional.js >> combined.min.js

# Process multiple files to separate outputs
for file in *.js; do
  minify "$file" > "${file%.js}.min.js"
done

Stdin Processing Mode

Format-Specific Processing

Process content from stdin with explicit format specification.

# JavaScript processing
minify --js < input.js
cat source.js | minify --js
echo "function test() { return true; }" | minify --js

# CSS processing  
minify --css < styles.css
curl -s https://example.com/style.css | minify --css

# HTML processing
minify --html < template.html
cat page.html | minify --html

# Auto-detection processing
minify --auto < unknown-content.txt
curl -s https://api.example.com/content | minify --auto

Stdin Processing Examples:

# JavaScript minification from stdin
cat << 'EOF' | minify --js
function calculateSum(numbers) {
    let total = 0;
    for (let i = 0; i < numbers.length; i++) {
        total += numbers[i];
    }
    return total;
}
EOF
# Output: function calculateSum(a){let b=0;for(let c=0;c<a.length;c++)b+=a[c];return b}

# CSS minification with pipe
echo "body { margin: 0px; padding: 10px; color: #ffffff; }" | minify --css  
# Output: body{margin:0;padding:10px;color:#fff}

# HTML minification
cat << 'EOF' | minify --html
<html>
  <head>
    <title>Test Page</title>
  </head>
  <body>
    <h1>Hello World</h1>
  </body>
</html>
EOF
# Output: <html><head><title>Test Page</title></head><body><h1>Hello World</h1></body></html>

Information Commands

Help Command

Display comprehensive usage information and available options.

minify --help
minify -h

# Output format:
# Usage: minify [options]
# Options:
#   -h, --help                  display this help and exit
#   -v, --version               display version and exit
#   --js                        minify javascript
#   --css                       minify css
#   --html                      minify html
#   --auto                      auto detect format

Version Command

Display the current version of the minify package.

minify --version
minify -v

# Output: v14.1.0

Information Command Examples:

# Get help information
minify --help
# Displays usage instructions and available options

# Check version
minify --version
# Displays: v14.1.0

# Version check in scripts
VERSION=$(minify --version)
echo "Using minify $VERSION"

Configuration Integration

.minify.json Configuration

The CLI automatically loads configuration from .minify.json files in the current directory or parent directories.

{
  "js": {
    "type": "terser",
    "terser": {
      "mangle": true,
      "compress": {
        "drop_console": true
      }
    }
  },
  "css": {
    "type": "clean-css",
    "clean-css": {
      "level": 2
    }
  },
  "html": {
    "removeComments": true,
    "collapseWhitespace": true,
    "minifyJS": true,
    "minifyCSS": true
  },
  "img": {
    "maxSize": 50000
  }
}

Configuration Usage Examples:

# Create project configuration
cat << 'EOF' > .minify.json
{
  "js": {
    "type": "esbuild",
    "esbuild": {
      "minifyIdentifiers": true,
      "minifyWhitespace": true
    }
  },
  "css": {
    "type": "lightningcss"
  }
}
EOF

# Use configuration with file processing
minify src/app.js assets/style.css
# Applies .minify.json settings automatically

# Use configuration with stdin
cat script.js | minify --js
# Uses esbuild settings from .minify.json

Error Handling and Exit Codes

CLI Error Handling

The CLI provides robust error handling with informative messages.

# Exit codes
# 0 - Success
# 1 - Error (file not found, processing error, etc.)

# Error handling behavior
set -e  # Exit on error
minify nonexistent.js 2>/dev/null || echo "File not found"

# Capture errors
ERROR_LOG=$(minify invalid-syntax.js 2>&1)
if [ $? -ne 0 ]; then
  echo "Minification failed: $ERROR_LOG"
fi

Error Handling Examples:

# File not found error
minify missing-file.js
# Error: ENOENT: no such file or directory, open 'missing-file.js'

# Unsupported file type
minify document.pdf
# Error: File type "pdf" not supported.

# Configuration file error
echo "{ invalid json }" > .minify.json
minify script.js
# Error: [Configuration parsing error message]

# Stdin timeout handling
timeout 5s minify --js  # Will timeout if no input provided

Advanced CLI Usage

Process Substitution

Use process substitution for complex workflows:

# Compare original and minified sizes
diff <(wc -c < original.js) <(minify original.js | wc -c)

# Minify and validate in pipeline
minify script.js | node -c  # Check syntax of minified code

# Process remote content
minify --css < <(curl -s https://example.com/style.css)

Batch Processing Scripts

Create efficient batch processing workflows:

#!/bin/bash
# Batch minification script

# Create output directory
mkdir -p dist/

# Process all JavaScript files
find src/ -name "*.js" -exec sh -c '
  minify "$1" > "dist/$(basename "$1" .js).min.js"
' _ {} \;

# Process all CSS files
find assets/ -name "*.css" -exec sh -c '
  minify "$1" > "dist/$(basename "$1" .css).min.css" 
' _ {} \;

echo "Minification complete!"

Integration with Build Tools

Integrate with common build tools and workflows:

# Makefile integration
minify-assets:
	minify src/app.js > dist/app.min.js
	minify assets/style.css > dist/style.min.css

# npm script integration
# package.json:
# "scripts": {
#   "minify": "minify src/*.js src/*.css"
# }

# CI/CD pipeline integration
minify assets/*.js assets/*.css > /dev/null
if [ $? -eq 0 ]; then
  echo "✓ Minification successful"
else
  echo "✗ Minification failed"
  exit 1
fi

Performance and Limitations

CLI Performance Characteristics

# Performance considerations
# - File I/O overhead for multiple files
# - Stdin buffer size limitations  
# - Configuration file parsing on each invocation
# - Process startup overhead for small files

# Optimization strategies
# - Process multiple files in single invocation
# - Use stdin for programmatic usage
# - Cache configuration parsing in scripts
# - Consider programmatic API for high-frequency usage

CLI Limitations

# Current limitations
# - No recursive directory processing built-in
# - No watch mode for file changes
# - No parallel processing of multiple files
# - No output directory specification
# - No source map generation support

# Workarounds
# Use find/xargs for recursive processing
find . -name "*.js" | xargs -I {} minify {}

# Use inotify for watch mode
inotifywait -m -e modify src/ | while read; do
  minify src/*.js > dist/bundle.min.js
done

docs

auto-detection.md

cli-interface.md

configuration.md

css-minification.md

html-minification.md

image-processing.md

index.md

javascript-minification.md

tile.json