image-edit-tools 1.0.5 → 1.0.8

package/tests/unit/add-text.test.ts

@@ -3,6 +3,7 @@ import { readFileSync } from 'fs'
 import { join, dirname } from 'path'
 import { fileURLToPath } from 'url'
 import { addText } from '../../src/ops/add-text.js'
+import sharp from 'sharp'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -74,4 +75,113 @@ describe('addText', () => {
     expect((result as any).bounds).toBeDefined()
     expect((result as any).bounds.contentBottom).toBeGreaterThan(50)
   })
+
+  // ── Spans tests ─────────────────────────────────────────────────────────────
+
+  describe('spans', () => {
+    it('renders mixed bold+normal spans in one line', async () => {
+      const result = await addText(sampleJpeg, {
+        layers: [{
+          text: '',
+          x: 20, y: 50, fontSize: 28, color: '#333',
+          spans: [
+            { text: 'normal ' },
+            { text: 'bold part', bold: true, color: '#000' },
+          ]
+        }]
+      })
+      expect(result.ok).toBe(true)
+      if (!result.ok) return
+      const meta = await sharp(result.data).metadata()
+      expect(meta.width).toBe(400)
+    })
+
+    it('renders italic and custom fontSize spans', async () => {
+      const result = await addText(sampleJpeg, {
+        layers: [{
+          text: '',
+          x: 20, y: 50, fontSize: 24, color: '#333',
+          spans: [
+            { text: 'normal ' },
+            { text: 'italic small', italic: true, fontSize: 16, color: '#666' },
+          ]
+        }]
+      })
+      expect(result.ok).toBe(true)
+    })
+
+    it('handles newline in span text', async () => {
+      const result = await addText(sampleJpeg, {
+        layers: [{
+          text: '',
+          x: 20, y: 50, fontSize: 24, color: '#333',
+          spans: [
+            { text: 'line one\n' },
+            { text: 'line two', bold: true },
+          ]
+        }]
+      })
+      expect(result.ok).toBe(true)
+    })
+
+    it('renders highlight background behind span', async () => {
+      const result = await addText(sampleJpeg, {
+        layers: [{
+          text: '',
+          x: 20, y: 50, fontSize: 24, color: '#333',
+          spans: [
+            { text: 'highlighted', highlight: '#FFFF00' },
+            { text: ' normal' },
+          ]
+        }]
+      })
+      expect(result.ok).toBe(true)
+    })
+
+    it('warns when maxWidth used with spans', async () => {
+      const result = await addText(sampleJpeg, {
+        layers: [{
+          text: '',
+          x: 20, y: 50, fontSize: 24, color: '#333',
+          maxWidth: 200,
+          spans: [{ text: 'hello' }]
+        }]
+      })
+      expect(result.ok).toBe(true)
+      if (!result.ok) return
+      expect(result.warnings).toContain(
+        'maxWidth is not supported with spans'
+      )
+    })
+
+    it('warns when both text and spans are provided', async () => {
+      const result = await addText(sampleJpeg, {
+        layers: [{
+          text: 'this should be ignored',
+          x: 20, y: 50, fontSize: 24, color: '#333',
+          spans: [{ text: 'spans win' }]
+        }]
+      })
+      expect(result.ok).toBe(true)
+      if (!result.ok) return
+      expect(result.warnings).toContain(
+        'text field ignored when spans is provided'
+      )
+    })
+
+    it('renders spans with background box', async () => {
+      const result = await addText(sampleJpeg, {
+        layers: [{
+          text: '',
+          x: 20, y: 50, fontSize: 24, color: '#333',
+          background: { color: '#EEE', padding: 8 },
+          spans: [
+            { text: 'with ' },
+            { text: 'background', bold: true },
+          ]
+        }]
+      })
+      expect(result.ok).toBe(true)
+    })
+  })
 })

package/tests/unit/clip-to-shape.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import sharp from 'sharp'
+import { clipToShape } from '../../src/ops/clip-to-shape.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('clipToShape', () => {
+  let sampleJpeg: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg')
+  })
+
+  it('clips to circle', async () => {
+    const result = await clipToShape(sampleJpeg, { shape: 'circle' })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.hasAlpha).toBe(true)
+  })
+
+  it('clips to rounded-rect with custom radius', async () => {
+    const result = await clipToShape(sampleJpeg, { shape: 'rounded-rect', borderRadius: 64 })
+    expect(result.ok).toBe(true)
+  })
+
+  it('clips to ellipse', async () => {
+    const result = await clipToShape(sampleJpeg, { shape: 'ellipse' })
+    expect(result.ok).toBe(true)
+  })
+})

package/tests/unit/draw-shape.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest'
+import sharp from 'sharp'
+import { drawShape } from '../../src/ops/draw-shape.js'
+
+describe('drawShape', () => {
+  it('draws a filled rect', async () => {
+    const result = await drawShape({ width: 200, height: 100, shape: 'rect', fill: '#FF0000', borderRadius: 16 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.width).toBe(200)
+    expect(meta.height).toBe(100)
+  })
+
+  it('draws a circle with stroke', async () => {
+    const result = await drawShape({ width: 100, height: 100, shape: 'circle', fill: '#00FF00', stroke: '#000000', strokeWidth: 3 })
+    expect(result.ok).toBe(true)
+  })
+
+  it('draws an ellipse', async () => {
+    const result = await drawShape({ width: 200, height: 100, shape: 'ellipse', fill: '#0000FF' })
+    expect(result.ok).toBe(true)
+  })
+
+  it('draws a line', async () => {
+    const result = await drawShape({ width: 200, height: 200, shape: 'line', stroke: '#FF0000', strokeWidth: 4, x1: 10, y1: 10, x2: 190, y2: 190 })
+    expect(result.ok).toBe(true)
+  })
+
+  it('returns error for unknown shape', async () => {
+    const result = await drawShape({ width: 100, height: 100, shape: 'hexagon' as any })
+    expect(result.ok).toBe(false)
+  })
+})

package/tests/unit/drop-shadow.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import sharp from 'sharp'
+import { dropShadow } from '../../src/ops/drop-shadow.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('dropShadow', () => {
+  let logoPng: Buffer
+
+  beforeAll(() => {
+    logoPng = fixture('logo.png') // 100x100
+  })
+
+  it('adds drop shadow with expanded canvas', async () => {
+    const result = await dropShadow(logoPng, { blur: 8, offsetX: 4, offsetY: 4 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    // Canvas should be expanded
+    expect(meta.width).toBeGreaterThan(100)
+    expect(meta.height).toBeGreaterThan(100)
+  })
+
+  it('adds shadow without expanding canvas', async () => {
+    const result = await dropShadow(logoPng, { expand: false, blur: 4 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.width).toBe(100)
+    expect(meta.height).toBe(100)
+  })
+
+  it('uses default options', async () => {
+    const result = await dropShadow(logoPng)
+    expect(result.ok).toBe(true)
+  })
+})

package/tests/unit/font-loader.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { resolveFontUrl } from '../../src/utils/font-loader.js';
+
+describe('resolveFontUrl', () => {
+  it('passes through file:// URLs unchanged', async () => {
+    const result = await resolveFontUrl('file:///usr/share/fonts/truetype/noto/NotoSans.ttf');
+    expect(result).toBe('file:///usr/share/fonts/truetype/noto/NotoSans.ttf');
+  });
+
+  it('converts absolute paths to file:// URLs', async () => {
+    const result = await resolveFontUrl('/home/user/fonts/MyFont.ttf');
+    expect(result).toMatch(/^file:\/\//);
+    expect(result).toContain('MyFont.ttf');
+    expect(result).toBe('file:///home/user/fonts/MyFont.ttf');
+  });
+
+  it('downloads and caches a direct woff2 URL', async () => {
+    // Use a real small font file from Google's CDN
+    const url = 'https://fonts.gstatic.com/s/inter/v18/UcCo3FwrK3iLTcviYwY.woff2';
+    const result = await resolveFontUrl(url);
+    expect(result).toMatch(/^file:\/\//);
+    expect(result).toMatch(/\.woff2$/);
+  }, { timeout: 15000 });
+
+  it('returns cached file on second call (no re-download)', async () => {
+    const url = 'https://fonts.gstatic.com/s/inter/v18/UcCo3FwrK3iLTcviYwY.woff2';
+    const first = await resolveFontUrl(url);
+    const second = await resolveFontUrl(url);
+    // Both should return identical paths (cache hit)
+    expect(second).toBe(first);
+  }, { timeout: 15000 });
+
+  it('resolves Google Fonts CSS URL to local file', async () => {
+    const url = 'https://fonts.googleapis.com/css2?family=Inter&display=swap';
+    const result = await resolveFontUrl(url);
+    expect(result).toMatch(/^file:\/\//);
+    expect(result).toMatch(/\.woff2$/);
+  }, { timeout: 15000 });
+});

package/tests/unit/gradient-overlay.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { gradientOverlay } from '../../src/ops/gradient-overlay.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('gradientOverlay', () => {
+  let sampleJpeg: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg')
+  })
+
+  it('applies default bottom gradient', async () => {
+    const result = await gradientOverlay(sampleJpeg)
+    expect(result.ok).toBe(true)
+  })
+
+  it('applies gradient with custom direction and color', async () => {
+    const result = await gradientOverlay(sampleJpeg, {
+      direction: 'top-right', color: '#FF0000', opacity: 0.5, coverage: 0.8
+    })
+    expect(result.ok).toBe(true)
+  })
+})

package/tests/unit/rotate.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import sharp from 'sharp'
+import { rotate } from '../../src/ops/rotate.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('rotate', () => {
+  let sampleJpeg: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg')
+  })
+
+  it('rotates 90 degrees', async () => {
+    const result = await rotate(sampleJpeg, { angle: 90 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    // 400x300 rotated 90° → 300x400
+    expect(meta.width).toBe(300)
+    expect(meta.height).toBe(400)
+  })
+
+  it('rotates 45 degrees with transparent bg', async () => {
+    const result = await rotate(sampleJpeg, { angle: 45 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    // Canvas expands for 45° rotation
+    expect(meta.width).toBeGreaterThan(400)
+  })
+
+  it('returns same buffer for 0 degrees', async () => {
+    const result = await rotate(sampleJpeg, { angle: 0 })
+    expect(result.ok).toBe(true)
+  })
+})