259 lines
9.7 KiB
JavaScript
259 lines
9.7 KiB
JavaScript
/**
|
||
* resize-images.mjs — local image optimizer for the campaign site draft.
|
||
*
|
||
* Takes one or more image paths (or folders, which are scanned recursively)
|
||
* and, for each: rotates per EXIF, resizes to at most `--max-width` keeping
|
||
* the aspect ratio (no upscaling), strips metadata and encodes two outputs
|
||
* by default — AVIF (lightest modern format, for the site) and WebP (the
|
||
* broadly accepted companion: design tools such as PenPot and older
|
||
* browsers do not open AVIF). `--format` narrows the set. Outputs keep the
|
||
* source basename into the Next.js `public/` folder (or `--out`), so the
|
||
* draft pages can reference `/arquivo.avif` directly.
|
||
*
|
||
* Usage:
|
||
* pnpm images:resize 1.jpg 2.png
|
||
* pnpm images:resize --out public/campanha --max-width 2560 fotos/*
|
||
* pnpm images:resize --format avif,webp --quality 80 ~/Downloads/foto.JPG
|
||
* pnpm images:resize --format webp ~/Downloads/foto.JPG
|
||
*
|
||
* AVIF encoding is slower than WebP/JPEG — a large batch is expected to
|
||
* take a few seconds per image.
|
||
*/
|
||
import { removeBackground } from '@imgly/background-removal-node'
|
||
import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises'
|
||
import { basename, join, resolve } from 'node:path'
|
||
import { pathToFileURL } from 'node:url'
|
||
import sharp from 'sharp'
|
||
|
||
import { dieWithLabel } from './lib/cli.mjs'
|
||
import {
|
||
INPUT_EXTENSIONS,
|
||
defaultQualityFor,
|
||
deriveOutputFileName,
|
||
maxWidthFor,
|
||
parseResizeArgs,
|
||
} from './lib/imageResize.mjs'
|
||
|
||
const die = dieWithLabel('images:resize')
|
||
|
||
const USAGE = `Uso: pnpm images:resize [opções] <caminhos...>
|
||
|
||
Redimensiona e converte imagens para a web, gravando na pasta public/.
|
||
Por padrão gera DUAS versões: .avif para o site e .webp para PenPot e
|
||
navegadores antigos — o webp sai bem menor (1x a tela desktop) porque é
|
||
só referência de draft, não asset de produção.
|
||
|
||
Opções:
|
||
--max-width <px> largura máxima de TODOS os formatos (default por
|
||
formato: avif 3840 = 2x desktop, webp/jpeg 1920 = 1x)
|
||
--format <fmt> formato(s) de saída: avif, webp, jpeg (default avif,webp)
|
||
--quality <1-100> qualidade de compressão (defaults: avif 60, webp 75, jpeg 82)
|
||
--remove-bg remove o fundo da foto com IA local (1a execução
|
||
baixa o modelo, ~40 MB, depois usa cache)
|
||
--out <dir> pasta de saída (default public/)
|
||
-h, --help mostra esta ajuda
|
||
|
||
Caminhos podem ser arquivos de imagem ou pastas (varridas recursivamente).
|
||
O nome do arquivo é mantido; só a extensão muda (foto.jpg -> foto.avif + foto.webp).`
|
||
|
||
/**
|
||
* Expands positional args into a sorted, deduped list of image files.
|
||
* Directories are walked recursively; anything else is kept as-is.
|
||
*
|
||
* @param {string[]} paths
|
||
* @returns {Promise<string[]>} absolute input paths
|
||
*/
|
||
const expandImagePaths = async (paths) => {
|
||
const found = new Set()
|
||
for (const path of paths) {
|
||
const absolute = resolve(path)
|
||
let info
|
||
try {
|
||
info = await stat(absolute)
|
||
} catch {
|
||
die(`${path} não existe`)
|
||
}
|
||
if (info.isDirectory()) {
|
||
const entries = await readdir(absolute, { recursive: true, withFileTypes: true })
|
||
for (const entry of entries) {
|
||
if (!entry.isFile()) continue
|
||
const lower = entry.name.toLowerCase()
|
||
if ([...INPUT_EXTENSIONS].some((ext) => lower.endsWith(ext))) {
|
||
// `parentPath` is absolute on Node >= 22 and relative on older —
|
||
// resolve() folds either spelling onto the scanned root.
|
||
found.add(resolve(absolute, entry.parentPath, entry.name))
|
||
}
|
||
}
|
||
} else if (info.isFile()) {
|
||
found.add(absolute)
|
||
}
|
||
}
|
||
return [...found].sort()
|
||
}
|
||
|
||
const formatBytes = (bytes) => {
|
||
if (bytes < 1024) return `${bytes} B`
|
||
if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`
|
||
return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
|
||
}
|
||
|
||
/**
|
||
* Loads one input and prepares it once for every output format: EXIF
|
||
* rotation is baked in, then (optionally) the background is removed with
|
||
* the local ONNX model. The result is the raw buffer every format encodes
|
||
* from, so the segmentation never runs per format.
|
||
*
|
||
* The imgly node package decodes only blobs whose `type` it knows
|
||
* (png/jpeg/webp) and does NOT sniff bytes — a bare `new Blob([buffer])`
|
||
* arrives with an empty type and dies with "Unsupported format: " (bug
|
||
* in 1.4.5). PNG is the lossless universal intermediate, declared
|
||
* explicitly.
|
||
*
|
||
* @param {string} input
|
||
* @param {boolean} removeBg
|
||
*/
|
||
const prepareImage = async (input, removeBg) => {
|
||
let buffer = await sharp(await readFile(input))
|
||
.rotate()
|
||
.toBuffer()
|
||
if (removeBg) {
|
||
buffer = await sharp(buffer).png().toBuffer()
|
||
const blob = new Blob([buffer], { type: 'image/png' })
|
||
const result = await removeBackground(blob, { output: { format: 'image/png' } })
|
||
buffer = Buffer.from(await result.arrayBuffer())
|
||
}
|
||
return buffer
|
||
}
|
||
|
||
/**
|
||
* Resizes + converts one prepared image to one format. Returns the
|
||
* width/height pair of the output for the summary. Never touches the
|
||
* source: the output path is derived from the basename and the target
|
||
* format, so it can only collide with the source when the input already is
|
||
* the output format AND sits in the output folder — which is refused.
|
||
* JPEG cannot hold the alpha channel left by background removal, so it is
|
||
* flattened onto white instead of leaking black.
|
||
*
|
||
* @param {Buffer} prepared
|
||
* @param {string} input
|
||
* @param {string} output
|
||
* @param {{ maxWidth: number | undefined, quality: number | undefined, format: 'avif' | 'webp' | 'jpeg', removeBg: boolean }} options
|
||
*/
|
||
const encodeImage = async (prepared, input, output, { maxWidth, quality, format, removeBg }) => {
|
||
if (resolve(input) === resolve(output)) {
|
||
throw new Error(
|
||
`saída colidiria com a fonte em ${basename(input)} — troque o formato ou use --out`,
|
||
)
|
||
}
|
||
let pipeline = sharp(prepared).resize({
|
||
width: maxWidthFor(format, maxWidth),
|
||
withoutEnlargement: true,
|
||
fit: 'inside',
|
||
})
|
||
if (removeBg && format === 'jpeg') pipeline = pipeline.flatten({ background: '#ffffff' })
|
||
const encoded = await pipeline
|
||
.toFormat(format, { quality: quality ?? defaultQualityFor(format) })
|
||
.toBuffer()
|
||
await writeFile(output, encoded)
|
||
const { width, height } = await sharp(encoded).metadata()
|
||
return { width: width ?? 0, height: height ?? 0 }
|
||
}
|
||
|
||
/**
|
||
* The shared resize+encode engine — the CLI entry point and `fill-image.mjs`
|
||
* (which chains this onto the model output) both call it with a
|
||
* `parseResizeArgs`-shaped options object.
|
||
*
|
||
* @param {ReturnType<typeof parseResizeArgs>} options
|
||
*/
|
||
export const runResizeImages = async (options) => {
|
||
if (options.help) {
|
||
console.log(USAGE)
|
||
return
|
||
}
|
||
|
||
const inputs = await expandImagePaths(options.paths)
|
||
if (inputs.length === 0) {
|
||
die(`nenhuma imagem encontrada nos caminhos informados (${options.paths.join(', ')})`)
|
||
}
|
||
|
||
const outDir = resolve(options.outDir)
|
||
await mkdir(outDir, { recursive: true })
|
||
|
||
const { formats, quality, maxWidth, removeBg } = options
|
||
const results = []
|
||
const failures = []
|
||
for (const input of inputs) {
|
||
const before = (await stat(input)).size
|
||
let prepared
|
||
try {
|
||
prepared = await prepareImage(input, removeBg)
|
||
} catch (error) {
|
||
failures.push(`${basename(input)}: ${error instanceof Error ? error.message : String(error)}`)
|
||
continue
|
||
}
|
||
for (const format of formats) {
|
||
const output = join(outDir, deriveOutputFileName(input, format))
|
||
try {
|
||
const { width, height } = await encodeImage(prepared, input, output, {
|
||
maxWidth,
|
||
quality,
|
||
format,
|
||
removeBg,
|
||
})
|
||
const after = (await stat(output)).size
|
||
results.push({
|
||
name: `${basename(input)} → .${format}`,
|
||
dimensions: `${width}×${height}`,
|
||
before,
|
||
after,
|
||
})
|
||
} catch (error) {
|
||
failures.push(
|
||
`${basename(input)} (.${format}): ${error instanceof Error ? error.message : String(error)}`,
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
const nameWidth = Math.max(...results.map((r) => r.name.length), 6)
|
||
console.log(`\n${'arquivo'.padEnd(nameWidth)} dimensão antes -> depois economia`)
|
||
console.log('-'.repeat(nameWidth + 54))
|
||
let totalBefore = 0
|
||
let totalAfter = 0
|
||
for (const result of results) {
|
||
totalBefore += result.before
|
||
totalAfter += result.after
|
||
const saved = 100 - (result.after / result.before) * 100
|
||
console.log(
|
||
`${result.name.padEnd(nameWidth)} ${result.dimensions.padEnd(9)} ${formatBytes(result.before).padEnd(8)} -> ${formatBytes(result.after).padEnd(9)} ${saved.toFixed(1).padStart(5)}%`,
|
||
)
|
||
}
|
||
if (results.length > 1) {
|
||
const saved = 100 - (totalAfter / totalBefore) * 100
|
||
console.log('-'.repeat(nameWidth + 54))
|
||
console.log(
|
||
`${'TOTAL'.padEnd(nameWidth)} ${String(results.length).padEnd(9)} ${formatBytes(totalBefore).padEnd(8)} -> ${formatBytes(totalAfter).padEnd(9)} ${saved.toFixed(1).padStart(5)}%`,
|
||
)
|
||
}
|
||
const widthSummary = maxWidth
|
||
? `largura máxima ${maxWidth}px`
|
||
: `largura por formato (${formats.map((f) => `${f} ${maxWidthFor(f)}px`).join(', ')})`
|
||
console.log(
|
||
`\n${results.length} arquivo(s) em ${join(outDir, '')} (${formats.join(', ')}, ${quality ? `qualidade ${quality}, ` : ''}${widthSummary}${removeBg ? ', fundo removido' : ''})\n`,
|
||
)
|
||
|
||
if (failures.length > 0) {
|
||
console.error(`\n${failures.length} falha(s):`)
|
||
for (const failure of failures) console.error(` - ${failure}`)
|
||
process.exit(1)
|
||
}
|
||
}
|
||
|
||
// CLI entry: only when run directly — `fill-image.mjs` imports the engine
|
||
// without triggering the CLI.
|
||
if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
|
||
runResizeImages(parseResizeArgs(process.argv.slice(2))).catch((error) =>
|
||
die(error instanceof Error ? error.message : String(error)),
|
||
)
|
||
}
|