gotodev-image-optimizer 0.1.0 → 0.1.2

package/src/core/encoder.ts

@@ -1,244 +0,0 @@
-import { readFileSync } from 'node:fs'
-import sharp from 'sharp'
-import { contentHash, sriHash } from '../utils/hash.ts'
-import type { AnalysisResult } from './analyzer.ts'
-import { analyzeImage, computeTargetQuality } from './analyzer.ts'
-import { isAnimatedFormat } from './formats.ts'
-import { preprocessImage } from './preprocessor.ts'
-import { sanitizeSvg } from './sanitizer.ts'
-import { autoTuneQuality } from './tuner.ts'
-import type { ImageVariant, ManifestEntry, OutputFormat, QualityTier, TierConfig } from './types.ts'
-import {
-  validateFileSize,
-  validateImageContent,
-  validateOutputFormat,
-  validatePath,
-} from './validator.ts'
-
-export interface EncodeOptions {
-  widths: number[]
-  formats: OutputFormat[]
-  tiers: Record<QualityTier, TierConfig>
-  autoTune: boolean
-  adaptive: boolean
-  preprocess: boolean
-  faceDetection: boolean
-  outDir: string
-}
-
-export interface EncodeResult {
-  entries: Record<string, ManifestEntry>
-}
-
-function readFileSafe(filePath: string): Buffer {
-  validatePath(filePath)
-  const buffer = readFileSync(filePath)
-  validateFileSize(buffer.length)
-  return buffer
-}
-
-async function encodeVariant(
-  source: string | Buffer,
-  width: number,
-  format: OutputFormat,
-  quality: number,
-  outDir: string,
-): Promise<ImageVariant | null> {
-  try {
-    validateOutputFormat(format)
-
-    const img = typeof source === 'string' ? sharp(source) : sharp(source)
-    const metadata = await img.metadata()
-
-    if ((metadata.width ?? 0) <= width) {
-      const buffer = await img[format]({ quality }).toBuffer()
-      const hash = contentHash(buffer)
-      const ext = format === 'jpeg' ? 'jpg' : format
-      const filename = `${hash}-${width}.${ext}`
-      const outPath = `${outDir}/${filename}`
-
-      await sharp(buffer).toFile(outPath)
-
-      return {
-        src: filename,
-        width,
-        format,
-        size: buffer.length,
-        integrity: sriHash(buffer),
-      }
-    }
-
-    const resized =
-      typeof source === 'string'
-        ? await sharp(source).resize(width).toBuffer()
-        : await sharp(source).resize(width).toBuffer()
-    const encoded = await sharp(resized)[format]({ quality }).toBuffer()
-    const hash = contentHash(encoded)
-    const ext = format === 'jpeg' ? 'jpg' : format
-    const filename = `${hash}-${width}.${ext}`
-    const outPath = `${outDir}/${filename}`
-
-    await sharp(encoded).toFile(outPath)
-
-    return {
-      src: filename,
-      width,
-      format,
-      size: encoded.length,
-      integrity: sriHash(encoded),
-    }
-  } catch {
-    return null
-  }
-}
-
-export async function encodeImage(
-  imagePath: string,
-  options: EncodeOptions,
-): Promise<ManifestEntry> {
-  const buffer = readFileSafe(imagePath)
-  const ext = imagePath.split('.').pop() ?? 'jpg'
-  const format = validateImageContent(buffer, ext)
-
-  if (format === 'svg') {
-    const content = buffer.toString('utf-8')
-    const sanitized = sanitizeSvg(content)
-    const hash = contentHash(Buffer.from(sanitized))
-    const filename = `${hash}.svg`
-    const svgBuffer = Buffer.from(sanitized)
-
-    return {
-      src: filename,
-      width: 0,
-      height: 0,
-      format: 'svg',
-      placeholder: '',
-      tiers: {} as Record<QualityTier, string>,
-      variants: [
-        {
-          src: filename,
-          width: 0,
-          format: 'webp',
-          size: svgBuffer.length,
-          integrity: sriHash(svgBuffer),
-        },
-      ],
-    }
-  }
-
-  if (isAnimatedFormat(format)) {
-    const img = sharp(buffer, { animated: true })
-    const metadata = await img.metadata()
-    const width = metadata.width ?? 0
-    const height = metadata.height ?? 0
-
-    const webpBuffer = await img.webp({ quality: 75 }).toBuffer()
-    const hash = contentHash(webpBuffer)
-    const filename = `${hash}.webp`
-
-    return {
-      src: filename,
-      width,
-      height,
-      format: 'gif',
-      placeholder: '',
-      tiers: {} as Record<QualityTier, string>,
-      variants: [
-        {
-          src: filename,
-          width,
-          format: 'webp',
-          size: webpBuffer.length,
-          integrity: sriHash(webpBuffer),
-        },
-      ],
-    }
-  }
-
-  const metadata = await sharp(buffer).metadata()
-  const originalWidth = metadata.width ?? 0
-  const originalHeight = metadata.height ?? 0
-
-  let placeholder = ''
-  if (originalWidth > 0 && originalHeight > 0) {
-    const placeholderBuffer = await sharp(buffer)
-      .resize(32, 32, { fit: 'inside' })
-      .webp({ quality: 20 })
-      .toBuffer()
-    placeholder = `data:image/webp;base64,${placeholderBuffer.toString('base64')}`
-  }
-
-  const tiers: Partial<Record<QualityTier, string>> = {}
-  const variants: ImageVariant[] = []
-
-  let analysis: AnalysisResult | null = null
-  let preprocessedSource: Buffer | null = null
-
-  if (options.adaptive || options.preprocess) {
-    try {
-      analysis = await analyzeImage(imagePath, 64, options.faceDetection)
-    } catch {}
-  }
-
-  if (options.preprocess && analysis) {
-    try {
-      preprocessedSource = await preprocessImage(imagePath, analysis)
-    } catch {}
-  }
-
-  const source = preprocessedSource ?? imagePath
-
-  for (const [tierKey, tierConfig] of Object.entries(options.tiers)) {
-    const tier = tierKey as QualityTier
-    let quality = tierConfig.quality
-
-    if (options.adaptive && analysis) {
-      try {
-        quality = computeTargetQuality(analysis, quality, {
-          minQuality: Math.max(20, quality - 30),
-          maxQuality: Math.min(95, quality + 10),
-        })
-      } catch {}
-    }
-
-    if (options.autoTune) {
-      try {
-        const tuned = await autoTuneQuality(source, 'webp', {
-          threshold: 0.97,
-          minQuality: Math.max(40, quality - 10),
-          maxQuality: Math.min(95, quality + 5),
-        })
-        quality = tuned.quality
-      } catch {}
-    }
-
-    const widths = tierConfig.widths.filter((w) => w <= originalWidth)
-    if (widths.length === 0) {
-      widths.push(originalWidth)
-    }
-
-    for (const w of widths) {
-      for (const fmt of options.formats) {
-        const variant = await encodeVariant(source, w, fmt, quality, options.outDir)
-        if (variant) {
-          variants.push(variant)
-        }
-      }
-    }
-
-    const bestVariant = variants.find((v) => v.format === 'webp')
-    if (bestVariant) {
-      tiers[tier] = bestVariant.src
-    }
-  }
-
-  return {
-    src: imagePath.split('/').pop() ?? 'image',
-    width: originalWidth,
-    height: originalHeight,
-    format,
-    placeholder,
-    tiers: tiers as Record<QualityTier, string>,
-    variants,
-  }
-}

package/src/core/formats.ts

@@ -1,97 +0,0 @@
-import type { ImageFormat, OutputFormat } from './types.ts'
-
-const MAGIC_BYTES: Record<string, Uint8Array> = {
-  jpeg: new Uint8Array([0xff, 0xd8, 0xff]),
-  png: new Uint8Array([0x89, 0x50, 0x4e, 0x47]),
-  webp: new Uint8Array([0x52, 0x49, 0x46, 0x46]),
-  gif: new Uint8Array([0x47, 0x49, 0x46, 0x38]),
-  bmp: new Uint8Array([0x42, 0x4d]),
-  tiff: new Uint8Array([0x49, 0x49, 0x2a, 0x00]),
-  ico: new Uint8Array([0x00, 0x00, 0x01, 0x00]),
-  svg: new Uint8Array([0x3c]), // '<'
-}
-
-const EXTENSION_MAP: Record<string, ImageFormat> = {
-  jpg: 'jpeg',
-  jpeg: 'jpeg',
-  png: 'png',
-  webp: 'webp',
-  avif: 'avif',
-  gif: 'gif',
-  svg: 'svg',
-  bmp: 'bmp',
-  tiff: 'tiff',
-  tif: 'tiff',
-  ico: 'ico',
-}
-
-export function detectFormat(buffer: Uint8Array, extension: string): ImageFormat {
-  const extFormat = EXTENSION_MAP[extension.toLowerCase()]
-  if (extFormat === 'svg') return 'svg'
-
-  for (const [format, magic] of Object.entries(MAGIC_BYTES)) {
-    if (buffer.length >= magic.length) {
-      let match = true
-      for (let i = 0; i < magic.length; i++) {
-        if (buffer[i] !== magic[i]) {
-          match = false
-          break
-        }
-      }
-      if (match) {
-        if (format === 'webp') {
-          const riffType = new TextDecoder().decode(buffer.slice(8, 12))
-          if (riffType === 'WEBP') return 'webp'
-          continue
-        }
-        return format as ImageFormat
-      }
-    }
-  }
-
-  return extFormat ?? 'jpeg'
-}
-
-export function getExtension(format: ImageFormat): string {
-  const map: Record<ImageFormat, string> = {
-    jpeg: 'jpg',
-    png: 'png',
-    webp: 'webp',
-    avif: 'avif',
-    gif: 'gif',
-    svg: 'svg',
-    bmp: 'bmp',
-    tiff: 'tiff',
-    ico: 'ico',
-  }
-  return map[format]
-}
-
-export function getMimeType(format: ImageFormat | OutputFormat): string {
-  const map: Record<string, string> = {
-    jpeg: 'image/jpeg',
-    png: 'image/png',
-    webp: 'image/webp',
-    avif: 'image/avif',
-    gif: 'image/gif',
-    svg: 'image/svg+xml',
-    bmp: 'image/bmp',
-    tiff: 'image/tiff',
-    ico: 'image/x-icon',
-  }
-  return map[format] ?? 'application/octet-stream'
-}
-
-export function isRasterFormat(format: ImageFormat): boolean {
-  return format !== 'svg'
-}
-
-export function isAnimatedFormat(format: ImageFormat): boolean {
-  return format === 'gif'
-}
-
-export function outputFormatsFrom(format: ImageFormat): OutputFormat[] {
-  if (format === 'svg') return []
-  if (format === 'gif') return ['webp', 'jpeg']
-  return ['avif', 'webp', 'jpeg']
-}

package/src/core/manifest.ts

@@ -1,38 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname } from 'node:path'
-import type { BuildManifest, ManifestEntry } from './types.ts'
-
-const MANIFEST_VERSION = '1.0.0'
-
-export function createManifest(): BuildManifest {
-  return {
-    version: MANIFEST_VERSION,
-    generatedAt: new Date().toISOString(),
-    entries: {},
-  }
-}
-
-export function addToManifest(manifest: BuildManifest, key: string, entry: ManifestEntry): void {
-  manifest.entries[key] = entry
-}
-
-export function writeManifest(manifest: BuildManifest, outPath: string): void {
-  const dir = dirname(outPath)
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true })
-  }
-  writeFileSync(outPath, JSON.stringify(manifest, null, 2))
-}
-
-export function loadManifest(manifestPath: string): BuildManifest | null {
-  try {
-    const content = readFileSafe(manifestPath)
-    return JSON.parse(content) as BuildManifest
-  } catch {
-    return null
-  }
-}
-
-function readFileSafe(path: string): string {
-  return readFileSync(path, 'utf-8')
-}

package/src/core/preprocessor.ts

@@ -1,58 +0,0 @@
-import sharp from 'sharp'
-import type { AnalysisResult } from './analyzer.ts'
-
-const OVERLAP_PX = 8
-
-export async function preprocessImage(
-  imagePath: string,
-  analysis: AnalysisResult,
-): Promise<Buffer> {
-  const { width, height, tileSize, tiles } = analysis
-
-  const sorted = [...tiles].sort((a, b) => b.importance - a.importance)
-  const topCount = Math.max(1, Math.ceil(sorted.length * 0.2))
-  const importantTiles = sorted.slice(0, topCount)
-
-  const composites: { input: Buffer; top: number; left: number }[] = []
-
-  for (const tile of importantTiles) {
-    const tileLeft = tile.x * tileSize
-    const tileTop = tile.y * tileSize
-    const tileW = Math.min(tileSize, width - tileLeft)
-    const tileH = Math.min(tileSize, height - tileTop)
-
-    const padL = tileLeft > 0 ? OVERLAP_PX : 0
-    const padT = tileTop > 0 ? OVERLAP_PX : 0
-    const padR = tileLeft + tileW < width ? OVERLAP_PX : 0
-    const padB = tileTop + tileH < height ? OVERLAP_PX : 0
-
-    const extLeft = tileLeft - padL
-    const extTop = tileTop - padT
-    const extWidth = tileW + padL + padR
-    const extHeight = tileH + padT + padB
-
-    const sigma = 1 + tile.importance * 1.2
-
-    const sharpened = await sharp(imagePath)
-      .extract({ left: extLeft, top: extTop, width: extWidth, height: extHeight })
-      .sharpen(sigma)
-      .png()
-      .toBuffer()
-
-    const trimmed = await sharp(sharpened)
-      .extract({ left: padL, top: padT, width: tileW, height: tileH })
-      .png()
-      .toBuffer()
-
-    composites.push({ input: trimmed, top: tileTop, left: tileLeft })
-  }
-
-  if (composites.length === 0) {
-    return sharp(imagePath).png().toBuffer()
-  }
-
-  return sharp(imagePath)
-    .composite(composites.map((c) => ({ input: c.input, top: c.top, left: c.left })))
-    .png()
-    .toBuffer()
-}

package/src/core/sanitizer.ts

@@ -1,43 +0,0 @@
-export function sanitizeSvg(input: string): string {
-  let sanitized = input
-
-  sanitized = sanitized.replace(/<script[\s\S]*?<\/script>/gi, '')
-  sanitized = sanitized.replace(/<\s*script[^>]*\/?>/gi, '')
-
-  sanitized = sanitized.replace(/\s+on\w+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, '')
-
-  sanitized = sanitized.replace(/javascript\s*:/gi, '')
-  sanitized = sanitized.replace(/data\s*:\s*text\s*\/\s*html/gi, '')
-  sanitized = sanitized.replace(/document\./gi, '')
-  sanitized = sanitized.replace(/window\./gi, '')
-  sanitized = sanitized.replace(/eval\s*\(/gi, '')
-  sanitized = sanitized.replace(/new\s+Function\s*\(/gi, '')
-  sanitized = sanitized.replace(/setTimeout\s*\(/gi, '')
-  sanitized = sanitized.replace(/setInterval\s*\(/gi, '')
-
-  return sanitized
-}
-
-export function validateSvgContent(input: string): boolean {
-  const dangerous = [
-    'script',
-    'onerror',
-    'onload',
-    'onclick',
-    'onmouseover',
-    'javascript:',
-    'data:text/html',
-    'document.cookie',
-    '<?',
-    '<%',
-  ]
-
-  const lower = input.toLowerCase()
-  for (const pattern of dangerous) {
-    if (lower.includes(pattern)) {
-      return false
-    }
-  }
-
-  return true
-}

package/src/core/tuner.ts

@@ -1,68 +0,0 @@
-import sharp from 'sharp'
-import { computeSSIM } from '../utils/ssim.ts'
-import type { OutputFormat } from './types.ts'
-
-const SSIM_THRESHOLD = 0.97
-const QUALITY_RANGE = [70, 75, 80, 85, 90, 95] as const
-
-export interface TunedResult {
-  quality: number
-  ssim: number
-  size: number
-}
-
-export async function autoTuneQuality(
-  source: string | Buffer,
-  format: OutputFormat,
-  options?: {
-    threshold?: number
-    minQuality?: number
-    maxQuality?: number
-  },
-): Promise<TunedResult> {
-  const threshold = options?.threshold ?? SSIM_THRESHOLD
-  const minQ = options?.minQuality ?? 70
-  const maxQ = options?.maxQuality ?? 95
-
-  const candidateQualities = QUALITY_RANGE.filter((q) => q >= minQ && q <= maxQ)
-
-  const original = await sharp(source)
-    .resize(256, 256, { fit: 'inside' })
-    .grayscale()
-    .raw()
-    .toBuffer()
-
-  const originalMeta = await sharp(source).metadata()
-  const resizeW = Math.min(256, originalMeta.width ?? 256)
-  const resizeH = Math.min(256, originalMeta.height ?? 256)
-
-  let best: TunedResult = { quality: minQ, ssim: 1, size: Number.POSITIVE_INFINITY }
-
-  for (const quality of candidateQualities) {
-    const { data, info } = await sharp(source)
-      .resize(resizeW, resizeH, { fit: 'inside' })
-      [format]({ quality })
-      .grayscale()
-      .raw()
-      .toBuffer({ resolveWithObject: true })
-
-    const ssim = computeSSIM(
-      new Uint8Array(original),
-      new Uint8Array(data),
-      info.width,
-      info.height,
-    )
-    const size = Buffer.byteLength(data)
-
-    if (ssim >= threshold && size < best.size) {
-      best = { quality, ssim, size }
-    }
-
-    if (ssim >= threshold && quality === minQ) {
-      return best
-    }
-  }
-
-  if (best.ssim >= threshold) return best
-  return { quality: maxQ, ssim: best.ssim, size: best.size }
-}

package/src/core/types.ts

@@ -1,83 +0,0 @@
-export type ImageFormat = 'jpeg' | 'png' | 'webp' | 'avif' | 'gif' | 'svg' | 'bmp' | 'tiff' | 'ico'
-
-export type OutputFormat = 'avif' | 'webp' | 'jpeg' | 'png'
-
-export type QualityTier = 'ultra' | 'high' | 'medium' | 'low'
-
-export interface TierConfig {
-  quality: number
-  widths: number[]
-}
-
-export interface PluginOptions {
-  tiers?: Partial<Record<QualityTier, TierConfig>>
-  adaptive?: boolean
-  autoTune?: boolean
-  formats?: OutputFormat[]
-  maxFileSize?: number
-  widths?: number[]
-  verbose?: boolean
-  preprocess?: boolean
-  faceDetection?: boolean
-}
-
-export interface ImageVariant {
-  src: string
-  width: number
-  format: OutputFormat
-  size: number
-  integrity: string
-}
-
-export interface ImageMetadata {
-  src: string
-  width: number
-  height: number
-  format: ImageFormat
-  placeholder: string
-  variants: ImageVariant[]
-  tiers: Record<QualityTier, string>
-  blurHash?: string
-}
-
-export interface TileAnalysis {
-  x: number
-  y: number
-  entropy: number
-  edgeDensity: number
-  importance: number
-  centerWeight: number
-}
-
-export interface TileQuality {
-  x: number
-  y: number
-  saliency: number
-  quality: number
-  weight: number
-}
-
-export interface DeviceFingerprint {
-  effectiveType: 'slow-2g' | '2g' | '3g' | '4g' | 'unknown'
-  deviceMemory: number
-  hardwareConcurrency: number
-  devicePixelRatio: number
-  saveData: boolean
-  tier: QualityTier
-}
-
-export interface ManifestEntry {
-  src: string
-  width: number
-  height: number
-  format: ImageFormat
-  placeholder: string
-  tiers: Record<QualityTier, string>
-  variants: ImageVariant[]
-}
-
-export interface BuildManifest {
-  version: string
-  generatedAt: string
-  entries: Record<string, ManifestEntry>
-}

package/src/core/validator.ts

@@ -1,63 +0,0 @@
-import { detectFormat } from './formats.ts'
-import type { ImageFormat } from './types.ts'
-
-export class ValidationError extends Error {
-  constructor(
-    message: string,
-    public readonly code: string,
-  ) {
-    super(message)
-    this.name = 'ValidationError'
-  }
-}
-
-const MAX_FILE_SIZE = 50 * 1024 * 1024
-const ALLOWED_EXTENSIONS = new Set([
-  'jpg',
-  'jpeg',
-  'png',
-  'webp',
-  'avif',
-  'gif',
-  'svg',
-  'bmp',
-  'tiff',
-  'tif',
-  'ico',
-])
-
-export function validatePath(filePath: string): void {
-  if (filePath.includes('..')) {
-    throw new ValidationError('Path traversal detected', 'PATH_TRAVERSAL')
-  }
-  if (filePath.includes('\0')) {
-    throw new ValidationError('Null byte in path', 'NULL_BYTE')
-  }
-}
-
-export function validateExtension(extension: string): void {
-  if (!ALLOWED_EXTENSIONS.has(extension.toLowerCase())) {
-    throw new ValidationError(`Unsupported file extension: .${extension}`, 'UNSUPPORTED_EXTENSION')
-  }
-}
-
-export function validateFileSize(size: number, maxSize: number = MAX_FILE_SIZE): void {
-  if (size > maxSize) {
-    throw new ValidationError(`File size ${size} exceeds maximum ${maxSize}`, 'FILE_TOO_LARGE')
-  }
-}
-
-export function validateImageContent(buffer: Uint8Array, extension: string): ImageFormat {
-  const detectedFormat = detectFormat(buffer, extension)
-  if (!detectedFormat) {
-    throw new ValidationError(`Cannot detect image format for .${extension}`, 'INVALID_FORMAT')
-  }
-  return detectedFormat
-}
-
-export function validateOutputFormat(format: string): void {
-  const allowed: string[] = ['avif', 'webp', 'jpeg', 'png']
-  if (!allowed.includes(format)) {
-    throw new ValidationError(`Unsupported output format: ${format}`, 'UNSUPPORTED_OUTPUT_FORMAT')
-  }
-}