gotodev-image-optimizer 0.1.1 → 0.1.2

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')
-  }
-}

package/src/index.ts

@@ -1,13 +0,0 @@
-export type { GImageProps } from './components/GImage.tsx'
-export { default as GImage } from './components/GImage.tsx'
-export type {
-  BuildManifest,
-  DeviceFingerprint,
-  ImageFormat,
-  ImageMetadata,
-  ManifestEntry,
-  OutputFormat,
-  PluginOptions,
-  QualityTier,
-} from './core/types.ts'
-export { default as gotodevImageOptimizer } from './vite-plugin.ts'

package/src/utils/entropy.ts

@@ -1,66 +0,0 @@
-export function computeEntropy(pixels: Uint8Array): number {
-  const histogram = new Float64Array(256)
-  const len = pixels.length
-
-  for (let i = 0; i < len; i++) {
-    const val = pixels[i]
-    if (val !== undefined) {
-      histogram[val] = (histogram[val] ?? 0) + 1
-    }
-  }
-
-  let entropy = 0
-  const lenF = len
-  for (let i = 0; i < 256; i++) {
-    const count = histogram[i]
-    if (count && count > 0) {
-      const p = count / lenF
-      entropy -= p * Math.log2(p)
-    }
-  }
-
-  return entropy
-}
-
-export function computeEdgeDensity(pixels: Uint8Array, width: number, height: number): number {
-  let edges = 0
-  let total = 0
-
-  for (let y = 1; y < height - 1; y++) {
-    for (let x = 1; x < width - 1; x++) {
-      const idx = y * width + x
-      const center = pixels[idx] ?? 0
-      const right = pixels[idx + 1] ?? 0
-      const down = pixels[idx + width] ?? 0
-      const dx = Math.abs(center - right)
-      const dy = Math.abs(center - down)
-
-      if (dx > 20 || dy > 20) {
-        edges++
-      }
-      total++
-    }
-  }
-
-  return total > 0 ? edges / total : 0
-}
-
-export function computeSaliency(pixels: Uint8Array, width: number, height: number): number {
-  const entropy = computeEntropy(pixels)
-  const edgeDensity = computeEdgeDensity(pixels, width, height)
-  const normalizedEntropy = entropy / 8.0
-  return normalizedEntropy * 0.5 + edgeDensity * 0.5
-}
-
-export function computeCenterWeight(
-  tileX: number,
-  tileY: number,
-  tilesX: number,
-  tilesY: number,
-): number {
-  const cx = (tileX + 0.5) / tilesX - 0.5
-  const cy = (tileY + 0.5) / tilesY - 0.5
-  const dist = Math.sqrt(cx * cx + cy * cy)
-  const normalizedDist = Math.min(1, dist / Math.SQRT1_2)
-  return 1.0 - normalizedDist * 0.4
-}

package/src/utils/hash.ts

@@ -1,10 +0,0 @@
-import { createHash } from 'node:crypto'
-
-export function contentHash(buffer: Buffer): string {
-  return createHash('sha384').update(buffer).digest('base64url').slice(0, 16)
-}
-
-export function sriHash(buffer: Buffer): string {
-  const hash = createHash('sha384').update(buffer).digest('base64')
-  return `sha384-${hash}`
-}

package/src/utils/ssim.ts

@@ -1,56 +0,0 @@
-export function computeSSIM(
-  original: Uint8Array,
-  compressed: Uint8Array,
-  width: number,
-  height: number,
-): number {
-  const K1 = 0.01
-  const K2 = 0.03
-  const L = 255
-  const C1 = (K1 * L) ** 2
-  const C2 = (K2 * L) ** 2
-
-  const windowSize = 8
-  const step = 4
-  let totalSSIM = 0
-  let windows = 0
-
-  for (let y = 0; y <= height - windowSize; y += step) {
-    for (let x = 0; x <= width - windowSize; x += step) {
-      let sumX = 0
-      let sumY = 0
-      let sumX2 = 0
-      let sumY2 = 0
-      let sumXY = 0
-      let count = 0
-
-      for (let wy = 0; wy < windowSize; wy++) {
-        for (let wx = 0; wx < windowSize; wx++) {
-          const idx = (y + wy) * width + (x + wx)
-          const ox = original[idx] ?? 0
-          const cy = compressed[idx] ?? 0
-          sumX += ox
-          sumY += cy
-          sumX2 += ox * ox
-          sumY2 += cy * cy
-          sumXY += ox * cy
-          count++
-        }
-      }
-
-      const muX = sumX / count
-      const muY = sumY / count
-      const sigmaX2 = sumX2 / count - muX * muX
-      const sigmaY2 = sumY2 / count - muY * muY
-      const sigmaXY = sumXY / count - muX * muY
-
-      const numerator = (2 * muX * muY + C1) * (2 * sigmaXY + C2)
-      const denominator = (muX * muX + muY * muY + C1) * (sigmaX2 + sigmaY2 + C2)
-
-      totalSSIM += denominator > 0 ? numerator / denominator : 1
-      windows++
-    }
-  }
-
-  return windows > 0 ? totalSSIM / windows : 1
-}

package/src/utils/worker.ts

@@ -1,73 +0,0 @@
-import { availableParallelism } from 'node:os'
-
-export type WorkerTask<T> = () => Promise<T>
-
-interface QueueItem {
-  task: WorkerTask<unknown>
-  resolve: (value: unknown) => void
-  reject: (reason: unknown) => void
-}
-
-const POOL_SIZE = Math.max(1, availableParallelism() - 1)
-
-export class WorkerPool {
-  private queue: QueueItem[] = []
-  private active = 0
-  private maxWorkers: number
-
-  constructor(maxWorkers: number = POOL_SIZE) {
-    this.maxWorkers = Math.max(1, maxWorkers)
-  }
-
-  async run<T>(task: WorkerTask<T>): Promise<T> {
-    if (this.active < this.maxWorkers) {
-      this.active++
-      try {
-        const result = await task()
-        this.active--
-        this.drain()
-        return result
-      } catch (error) {
-        this.active--
-        this.drain()
-        throw error
-      }
-    }
-
-    return new Promise<T>((resolve, reject) => {
-      this.queue.push({
-        task: task as WorkerTask<unknown>,
-        resolve: resolve as (value: unknown) => void,
-        reject,
-      })
-    })
-  }
-
-  private drain(): void {
-    while (this.active < this.maxWorkers && this.queue.length > 0) {
-      const item = this.queue.shift()
-      if (!item) break
-      this.active++
-      item
-        .task()
-        .then((result) => {
-          this.active--
-          item.resolve(result)
-          this.drain()
-        })
-        .catch((error) => {
-          this.active--
-          item.reject(error)
-          this.drain()
-        })
-    }
-  }
-
-  get pending(): number {
-    return this.queue.length
-  }
-
-  get running(): number {
-    return this.active
-  }
-}