0
# CLI Interface
1
2
Comprehensive command-line interface for minifying web assets with support for file processing, stdin/stdout operations, and flexible configuration options.
3
4
## Capabilities
5
6
### CLI Command Structure
7
8
The minify CLI provides multiple operation modes for different use cases.
9
10
```bash { .api }
11
# File processing
12
minify [files...]
13
14
# Stdin processing with format specification
15
minify --js # Process stdin as JavaScript
16
minify --css # Process stdin as CSS
17
minify --html # Process stdin as HTML
18
minify --auto # Auto-detect stdin format
19
20
# Information commands
21
minify --help # Display help information
22
minify --version # Display version information
23
```
24
25
**Basic Usage Examples:**
26
27
```bash
28
# Minify a single file
29
minify script.js
30
31
# Minify multiple files
32
minify app.js styles.css index.html
33
34
# Minify with output redirection
35
minify script.js > script.min.js
36
37
# Process stdin with format detection
38
cat source.js | minify --js
39
40
# Auto-detect format from stdin
41
echo "body { color: red; }" | minify --auto
42
```
43
44
## File Processing Mode
45
46
### Multiple File Processing
47
48
Process multiple files simultaneously with automatic format detection based on file extensions.
49
50
```bash { .api }
51
# Syntax
52
minify file1.js file2.css file3.html [options]
53
54
# Supported extensions
55
# .js - JavaScript files
56
# .css - CSS files
57
# .html - HTML files
58
```
59
60
**File Processing Examples:**
61
62
```bash
63
# Single file minification
64
minify app.js
65
# Output: Minified JavaScript content to stdout
66
67
# Multiple mixed files
68
minify src/main.js assets/style.css templates/index.html
69
# Output: Each file's minified content in sequence
70
71
# Wildcard file selection
72
minify assets/*.css
73
# Output: All CSS files in assets/ directory minified
74
75
# Complex file patterns
76
minify src/**/*.js dist/*.css
77
# Output: All JS files recursively from src/ and CSS from dist/
78
```
79
80
### File Output Handling
81
82
The CLI outputs minified content to stdout by default:
83
84
```bash
85
# Direct console output
86
minify script.js
87
# Displays minified content
88
89
# Save to new file
90
minify script.js > script.min.js
91
92
# Append to existing file
93
minify additional.js >> combined.min.js
94
95
# Process multiple files to separate outputs
96
for file in *.js; do
97
minify "$file" > "${file%.js}.min.js"
98
done
99
```
100
101
## Stdin Processing Mode
102
103
### Format-Specific Processing
104
105
Process content from stdin with explicit format specification.
106
107
```bash { .api }
108
# JavaScript processing
109
minify --js < input.js
110
cat source.js | minify --js
111
echo "function test() { return true; }" | minify --js
112
113
# CSS processing
114
minify --css < styles.css
115
curl -s https://example.com/style.css | minify --css
116
117
# HTML processing
118
minify --html < template.html
119
cat page.html | minify --html
120
121
# Auto-detection processing
122
minify --auto < unknown-content.txt
123
curl -s https://api.example.com/content | minify --auto
124
```
125
126
**Stdin Processing Examples:**
127
128
```bash
129
# JavaScript minification from stdin
130
cat << 'EOF' | minify --js
131
function calculateSum(numbers) {
132
let total = 0;
133
for (let i = 0; i < numbers.length; i++) {
134
total += numbers[i];
135
}
136
return total;
137
}
138
EOF
139
# Output: function calculateSum(a){let b=0;for(let c=0;c<a.length;c++)b+=a[c];return b}
140
141
# CSS minification with pipe
142
echo "body { margin: 0px; padding: 10px; color: #ffffff; }" | minify --css
143
# Output: body{margin:0;padding:10px;color:#fff}
144
145
# HTML minification
146
cat << 'EOF' | minify --html
147
<html>
148
<head>
149
<title>Test Page</title>
150
</head>
151
<body>
152
<h1>Hello World</h1>
153
</body>
154
</html>
155
EOF
156
# Output: <html><head><title>Test Page</title></head><body><h1>Hello World</h1></body></html>
157
```
158
159
## Information Commands
160
161
### Help Command
162
163
Display comprehensive usage information and available options.
164
165
```bash { .api }
166
minify --help
167
minify -h
168
169
# Output format:
170
# Usage: minify [options]
171
# Options:
172
# -h, --help display this help and exit
173
# -v, --version display version and exit
174
# --js minify javascript
175
# --css minify css
176
# --html minify html
177
# --auto auto detect format
178
```
179
180
### Version Command
181
182
Display the current version of the minify package.
183
184
```bash { .api }
185
minify --version
186
minify -v
187
188
# Output: v14.1.0
189
```
190
191
**Information Command Examples:**
192
193
```bash
194
# Get help information
195
minify --help
196
# Displays usage instructions and available options
197
198
# Check version
199
minify --version
200
# Displays: v14.1.0
201
202
# Version check in scripts
203
VERSION=$(minify --version)
204
echo "Using minify $VERSION"
205
```
206
207
## Configuration Integration
208
209
### .minify.json Configuration
210
211
The CLI automatically loads configuration from `.minify.json` files in the current directory or parent directories.
212
213
```json { .api }
214
{
215
"js": {
216
"type": "terser",
217
"terser": {
218
"mangle": true,
219
"compress": {
220
"drop_console": true
221
}
222
}
223
},
224
"css": {
225
"type": "clean-css",
226
"clean-css": {
227
"level": 2
228
}
229
},
230
"html": {
231
"removeComments": true,
232
"collapseWhitespace": true,
233
"minifyJS": true,
234
"minifyCSS": true
235
},
236
"img": {
237
"maxSize": 50000
238
}
239
}
240
```
241
242
**Configuration Usage Examples:**
243
244
```bash
245
# Create project configuration
246
cat << 'EOF' > .minify.json
247
{
248
"js": {
249
"type": "esbuild",
250
"esbuild": {
251
"minifyIdentifiers": true,
252
"minifyWhitespace": true
253
}
254
},
255
"css": {
256
"type": "lightningcss"
257
}
258
}
259
EOF
260
261
# Use configuration with file processing
262
minify src/app.js assets/style.css
263
# Applies .minify.json settings automatically
264
265
# Use configuration with stdin
266
cat script.js | minify --js
267
# Uses esbuild settings from .minify.json
268
```
269
270
## Error Handling and Exit Codes
271
272
### CLI Error Handling
273
274
The CLI provides robust error handling with informative messages.
275
276
```bash { .api }
277
# Exit codes
278
# 0 - Success
279
# 1 - Error (file not found, processing error, etc.)
280
281
# Error handling behavior
282
set -e # Exit on error
283
minify nonexistent.js 2>/dev/null || echo "File not found"
284
285
# Capture errors
286
ERROR_LOG=$(minify invalid-syntax.js 2>&1)
287
if [ $? -ne 0 ]; then
288
echo "Minification failed: $ERROR_LOG"
289
fi
290
```
291
292
**Error Handling Examples:**
293
294
```bash
295
# File not found error
296
minify missing-file.js
297
# Error: ENOENT: no such file or directory, open 'missing-file.js'
298
299
# Unsupported file type
300
minify document.pdf
301
# Error: File type "pdf" not supported.
302
303
# Configuration file error
304
echo "{ invalid json }" > .minify.json
305
minify script.js
306
# Error: [Configuration parsing error message]
307
308
# Stdin timeout handling
309
timeout 5s minify --js # Will timeout if no input provided
310
```
311
312
## Advanced CLI Usage
313
314
### Process Substitution
315
316
Use process substitution for complex workflows:
317
318
```bash
319
# Compare original and minified sizes
320
diff <(wc -c < original.js) <(minify original.js | wc -c)
321
322
# Minify and validate in pipeline
323
minify script.js | node -c # Check syntax of minified code
324
325
# Process remote content
326
minify --css < <(curl -s https://example.com/style.css)
327
```
328
329
### Batch Processing Scripts
330
331
Create efficient batch processing workflows:
332
333
```bash
334
#!/bin/bash
335
# Batch minification script
336
337
# Create output directory
338
mkdir -p dist/
339
340
# Process all JavaScript files
341
find src/ -name "*.js" -exec sh -c '
342
minify "$1" > "dist/$(basename "$1" .js).min.js"
343
' _ {} \;
344
345
# Process all CSS files
346
find assets/ -name "*.css" -exec sh -c '
347
minify "$1" > "dist/$(basename "$1" .css).min.css"
348
' _ {} \;
349
350
echo "Minification complete!"
351
```
352
353
### Integration with Build Tools
354
355
Integrate with common build tools and workflows:
356
357
```bash
358
# Makefile integration
359
minify-assets:
360
minify src/app.js > dist/app.min.js
361
minify assets/style.css > dist/style.min.css
362
363
# npm script integration
364
# package.json:
365
# "scripts": {
366
# "minify": "minify src/*.js src/*.css"
367
# }
368
369
# CI/CD pipeline integration
370
minify assets/*.js assets/*.css > /dev/null
371
if [ $? -eq 0 ]; then
372
echo "✓ Minification successful"
373
else
374
echo "✗ Minification failed"
375
exit 1
376
fi
377
```
378
379
## Performance and Limitations
380
381
### CLI Performance Characteristics
382
383
```bash { .api }
384
# Performance considerations
385
# - File I/O overhead for multiple files
386
# - Stdin buffer size limitations
387
# - Configuration file parsing on each invocation
388
# - Process startup overhead for small files
389
390
# Optimization strategies
391
# - Process multiple files in single invocation
392
# - Use stdin for programmatic usage
393
# - Cache configuration parsing in scripts
394
# - Consider programmatic API for high-frequency usage
395
```
396
397
### CLI Limitations
398
399
```bash
400
# Current limitations
401
# - No recursive directory processing built-in
402
# - No watch mode for file changes
403
# - No parallel processing of multiple files
404
# - No output directory specification
405
# - No source map generation support
406
407
# Workarounds
408
# Use find/xargs for recursive processing
409
find . -name "*.js" | xargs -I {} minify {}
410
411
# Use inotify for watch mode
412
inotifywait -m -e modify src/ | while read; do
413
minify src/*.js > dist/bundle.min.js
414
done
415
```