@mrdemonwolf/iconwolf 0.1.1

package/tests/utils/image.test.ts

@@ -0,0 +1,207 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import sharp from 'sharp';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import {
+  parseHexColor,
+  validateSourceImage,
+  resizeImage,
+  createAdaptiveForeground,
+  createSolidBackground,
+  createMonochromeIcon,
+  applyRoundedCorners,
+} from '../../src/utils/image.js';
+import { createTestPng, createTmpDir, cleanDir } from '../helpers.js';
+
+let tmpDir: string;
+let testPng: string;
+
+beforeAll(async () => {
+  tmpDir = createTmpDir();
+  testPng = await createTestPng(1024, 1024, tmpDir);
+});
+
+afterAll(() => {
+  cleanDir(tmpDir);
+});
+
+describe('parseHexColor', () => {
+  it('parses 6-digit hex with #', () => {
+    expect(parseHexColor('#FF6B35')).toEqual({ r: 255, g: 107, b: 53 });
+  });
+
+  it('parses 6-digit hex without #', () => {
+    expect(parseHexColor('FF6B35')).toEqual({ r: 255, g: 107, b: 53 });
+  });
+
+  it('parses 3-digit shorthand', () => {
+    expect(parseHexColor('#FFF')).toEqual({ r: 255, g: 255, b: 255 });
+  });
+
+  it('parses black', () => {
+    expect(parseHexColor('#000000')).toEqual({ r: 0, g: 0, b: 0 });
+  });
+
+  it('throws on invalid length', () => {
+    expect(() => parseHexColor('#FFFFF')).toThrow('Invalid hex color');
+  });
+
+  it('throws on non-hex characters', () => {
+    expect(() => parseHexColor('#GGGGGG')).toThrow('non-hex characters');
+  });
+});
+
+describe('validateSourceImage', () => {
+  it('accepts a valid square PNG', async () => {
+    const meta = await validateSourceImage(testPng);
+    expect(meta.width).toBe(1024);
+    expect(meta.height).toBe(1024);
+    expect(meta.format).toBe('png');
+  });
+
+  it('rejects non-square images', async () => {
+    const rectPng = path.join(tmpDir, 'rect.png');
+    await sharp({
+      create: {
+        width: 1024,
+        height: 512,
+        channels: 4,
+        background: { r: 0, g: 0, b: 0, alpha: 255 },
+      },
+    })
+      .png()
+      .toFile(rectPng);
+
+    await expect(validateSourceImage(rectPng)).rejects.toThrow(
+      'must be square',
+    );
+  });
+
+  it('rejects non-PNG formats', async () => {
+    const jpgFile = path.join(tmpDir, 'test.jpg');
+    await sharp({
+      create: {
+        width: 100,
+        height: 100,
+        channels: 3,
+        background: { r: 0, g: 0, b: 0 },
+      },
+    })
+      .jpeg()
+      .toFile(jpgFile);
+
+    await expect(validateSourceImage(jpgFile)).rejects.toThrow('must be a PNG');
+  });
+
+  it('throws on missing file', async () => {
+    await expect(validateSourceImage('/tmp/nonexistent.png')).rejects.toThrow();
+  });
+});
+
+describe('resizeImage', () => {
+  it('resizes to target dimensions', async () => {
+    const output = path.join(tmpDir, 'resized.png');
+    const result = await resizeImage(testPng, 48, 48, output);
+
+    expect(result.width).toBe(48);
+    expect(result.height).toBe(48);
+    expect(result.size).toBeGreaterThan(0);
+    expect(fs.existsSync(output)).toBe(true);
+  });
+
+  it('produces a valid PNG', async () => {
+    const output = path.join(tmpDir, 'resized-check.png');
+    await resizeImage(testPng, 256, 256, output);
+
+    const meta = await sharp(output).metadata();
+    expect(meta.format).toBe('png');
+    expect(meta.width).toBe(256);
+    expect(meta.height).toBe(256);
+  });
+});
+
+describe('createAdaptiveForeground', () => {
+  it('creates a 1024x1024 foreground with centered artwork', async () => {
+    const output = path.join(tmpDir, 'foreground.png');
+    const result = await createAdaptiveForeground(testPng, 1024, output);
+
+    expect(result.width).toBe(1024);
+    expect(result.height).toBe(1024);
+    expect(fs.existsSync(output)).toBe(true);
+  });
+});
+
+describe('createSolidBackground', () => {
+  it('creates a solid color PNG', async () => {
+    const output = path.join(tmpDir, 'bg.png');
+    const result = await createSolidBackground('#FF0000', 1024, output);
+
+    expect(result.width).toBe(1024);
+    expect(result.height).toBe(1024);
+
+    const meta = await sharp(output).metadata();
+    expect(meta.format).toBe('png');
+  });
+});
+
+describe('createMonochromeIcon', () => {
+  it('creates a grayscale 1024x1024 icon', async () => {
+    const output = path.join(tmpDir, 'mono.png');
+    const result = await createMonochromeIcon(testPng, 1024, output);
+
+    expect(result.width).toBe(1024);
+    expect(result.height).toBe(1024);
+    expect(fs.existsSync(output)).toBe(true);
+  });
+});
+
+describe('applyRoundedCorners', () => {
+  it('returns a PNG buffer with alpha channel', async () => {
+    const input = await sharp({
+      create: {
+        width: 48,
+        height: 48,
+        channels: 4,
+        background: { r: 255, g: 0, b: 0, alpha: 255 },
+      },
+    })
+      .png()
+      .toBuffer();
+
+    const result = await applyRoundedCorners(input, 48);
+    const meta = await sharp(result).metadata();
+
+    expect(meta.format).toBe('png');
+    expect(meta.width).toBe(48);
+    expect(meta.height).toBe(48);
+    expect(meta.channels).toBe(4);
+  });
+
+  it('produces transparent corners', async () => {
+    const input = await sharp({
+      create: {
+        width: 100,
+        height: 100,
+        channels: 4,
+        background: { r: 255, g: 0, b: 0, alpha: 255 },
+      },
+    })
+      .png()
+      .toBuffer();
+
+    const result = await applyRoundedCorners(input, 100);
+    const { data, info } = await sharp(result)
+      .raw()
+      .toBuffer({ resolveWithObject: true });
+
+    // Top-left corner pixel (0,0) should be transparent due to rounding
+    const topLeftAlpha = data[3]; // RGBA, alpha is at index 3
+    expect(topLeftAlpha).toBe(0);
+
+    // Center pixel should be fully opaque
+    const centerIdx =
+      (Math.floor(info.height / 2) * info.width + Math.floor(info.width / 2)) *
+      4;
+    expect(data[centerIdx + 3]).toBe(255);
+  });
+});

package/tests/utils/logger.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as logger from '../../src/utils/logger.js';
+
+let logOutput: string[];
+let errorOutput: string[];
+
+beforeEach(() => {
+  logOutput = [];
+  errorOutput = [];
+  vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+    logOutput.push(args.map(String).join(' '));
+  });
+  vi.spyOn(console, 'error').mockImplementation((...args: unknown[]) => {
+    errorOutput.push(args.map(String).join(' '));
+  });
+});
+
+describe('banner', () => {
+  it('prints the iconwolf banner', () => {
+    logger.banner();
+    expect(logOutput).toHaveLength(1);
+    expect(logOutput[0]).toContain('iconwolf');
+    expect(logOutput[0]).toContain('app icon generator');
+  });
+});
+
+describe('info', () => {
+  it('prints an info message', () => {
+    logger.info('test message');
+    expect(logOutput).toHaveLength(1);
+    expect(logOutput[0]).toContain('info');
+    expect(logOutput[0]).toContain('test message');
+  });
+});
+
+describe('success', () => {
+  it('prints a success message', () => {
+    logger.success('operation complete');
+    expect(logOutput).toHaveLength(1);
+    expect(logOutput[0]).toContain('done');
+    expect(logOutput[0]).toContain('operation complete');
+  });
+});
+
+describe('generated', () => {
+  it('prints file path and dimensions', () => {
+    logger.generated({
+      filePath: '/output/icon.png',
+      width: 1024,
+      height: 1024,
+      size: 6800,
+    });
+    expect(logOutput).toHaveLength(1);
+    expect(logOutput[0]).toContain('generated');
+    expect(logOutput[0]).toContain('/output/icon.png');
+    expect(logOutput[0]).toContain('1024x1024');
+    expect(logOutput[0]).toContain('6.6 KB');
+  });
+
+  it('formats sub-KB sizes', () => {
+    logger.generated({
+      filePath: '/output/favicon.png',
+      width: 48,
+      height: 48,
+      size: 400,
+    });
+    expect(logOutput[0]).toContain('0.4 KB');
+  });
+});
+
+describe('warn', () => {
+  it('prints a warning message', () => {
+    logger.warn('something off');
+    expect(logOutput).toHaveLength(1);
+    expect(logOutput[0]).toContain('warn');
+    expect(logOutput[0]).toContain('something off');
+  });
+});
+
+describe('error', () => {
+  it('prints to stderr', () => {
+    logger.error('something broke');
+    expect(errorOutput).toHaveLength(1);
+    expect(errorOutput[0]).toContain('error');
+    expect(errorOutput[0]).toContain('something broke');
+  });
+
+  it('does not print to stdout', () => {
+    logger.error('fail');
+    expect(logOutput).toHaveLength(0);
+  });
+});
+
+describe('summary', () => {
+  it('prints file count and total size', () => {
+    logger.summary([
+      { filePath: '/a.png', width: 1024, height: 1024, size: 5000 },
+      { filePath: '/b.png', width: 1024, height: 1024, size: 3000 },
+    ]);
+    expect(logOutput).toHaveLength(1);
+    expect(logOutput[0]).toContain('2 files generated');
+    expect(logOutput[0]).toContain('7.8 KB total');
+  });
+
+  it('uses singular for one file', () => {
+    logger.summary([
+      { filePath: '/a.png', width: 1024, height: 1024, size: 1024 },
+    ]);
+    expect(logOutput[0]).toContain('1 file generated');
+    expect(logOutput[0]).not.toContain('files');
+  });
+});
+
+describe('updateNotice', () => {
+  it('prints version upgrade info', () => {
+    logger.updateNotice('0.0.6', '0.0.7');
+    expect(logOutput).toHaveLength(2);
+    expect(logOutput[0]).toContain('update');
+    expect(logOutput[0]).toContain('0.0.6');
+    expect(logOutput[0]).toContain('0.0.7');
+    expect(logOutput[0]).toContain('New version available');
+  });
+
+  it('includes brew upgrade instruction', () => {
+    logger.updateNotice('0.0.6', '0.0.7');
+    expect(logOutput[1]).toContain('brew upgrade iconwolf');
+  });
+});

package/tests/utils/paths.test.ts

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, it, expect, vi } from 'vitest';
+import {
+  resolveOutputPath,
+  OUTPUT_FILES,
+  DEFAULT_OUTPUT_DIR,
+  resolveDefaultOutputDir,
+} from '../../src/utils/paths.js';
+
+describe('paths', () => {
+  it('DEFAULT_OUTPUT_DIR is ./assets/images', () => {
+    expect(DEFAULT_OUTPUT_DIR).toBe('./assets/images');
+  });
+
+  it('resolveDefaultOutputDir returns src/assets/images when src/ exists', () => {
+    vi.spyOn(fs, 'existsSync').mockReturnValue(true);
+    vi.spyOn(fs, 'statSync').mockReturnValue({
+      isDirectory: () => true,
+    } as fs.Stats);
+    expect(resolveDefaultOutputDir()).toBe('./src/assets/images');
+    vi.restoreAllMocks();
+  });
+
+  it('resolveDefaultOutputDir returns assets/images when no src/', () => {
+    vi.spyOn(fs, 'existsSync').mockReturnValue(false);
+    expect(resolveDefaultOutputDir()).toBe('./assets/images');
+    vi.restoreAllMocks();
+  });
+
+  it('OUTPUT_FILES contains all expected file names', () => {
+    expect(OUTPUT_FILES.icon).toBe('icon.png');
+    expect(OUTPUT_FILES.androidForeground).toBe('adaptive-icon.png');
+    expect(OUTPUT_FILES.androidBackground).toBe('android-icon-background.png');
+    expect(OUTPUT_FILES.androidMonochrome).toBe('monochrome-icon.png');
+    expect(OUTPUT_FILES.favicon).toBe('favicon.png');
+    expect(OUTPUT_FILES.splashIcon).toBe('splash-icon.png');
+  });
+
+  it('resolveOutputPath returns absolute path', () => {
+    const result = resolveOutputPath('/tmp/out', 'icon.png');
+    expect(result).toBe(path.resolve('/tmp/out', 'icon.png'));
+    expect(path.isAbsolute(result)).toBe(true);
+  });
+
+  it('resolveOutputPath resolves relative dirs', () => {
+    const result = resolveOutputPath('./assets', 'favicon.png');
+    expect(path.isAbsolute(result)).toBe(true);
+    expect(result.endsWith('favicon.png')).toBe(true);
+  });
+});

package/tests/utils/update-notifier.test.ts

@@ -0,0 +1,184 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  isNewerVersion,
+  readCachedUpdateInfo,
+  refreshCacheInBackground,
+} from '../../src/utils/update-notifier.js';
+
+describe('isNewerVersion', () => {
+  it('returns true when latest patch is newer', () => {
+    expect(isNewerVersion('0.0.6', '0.0.7')).toBe(true);
+  });
+
+  it('returns true when latest minor is newer', () => {
+    expect(isNewerVersion('0.0.6', '0.1.0')).toBe(true);
+  });
+
+  it('returns true when latest major is newer', () => {
+    expect(isNewerVersion('0.0.6', '1.0.0')).toBe(true);
+  });
+
+  it('returns false when versions are equal', () => {
+    expect(isNewerVersion('0.0.6', '0.0.6')).toBe(false);
+  });
+
+  it('returns false when current is newer', () => {
+    expect(isNewerVersion('0.0.7', '0.0.6')).toBe(false);
+  });
+
+  it('handles different segment lengths', () => {
+    expect(isNewerVersion('1.0', '1.0.1')).toBe(true);
+    expect(isNewerVersion('1.0.1', '1.0')).toBe(false);
+  });
+});
+
+describe('readCachedUpdateInfo', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns null when cache file is missing', () => {
+    vi.spyOn(fs, 'readFileSync').mockImplementation(() => {
+      throw new Error('ENOENT');
+    });
+    expect(readCachedUpdateInfo('0.0.6')).toBeNull();
+  });
+
+  it('returns updateAvailable true when latest is newer', () => {
+    vi.spyOn(fs, 'readFileSync').mockReturnValue(
+      JSON.stringify({ latestVersion: '0.0.7', checkedAt: Date.now() }),
+    );
+    const result = readCachedUpdateInfo('0.0.6');
+    expect(result).toEqual({
+      updateAvailable: true,
+      currentVersion: '0.0.6',
+      latestVersion: '0.0.7',
+    });
+  });
+
+  it('returns updateAvailable false when versions are equal', () => {
+    vi.spyOn(fs, 'readFileSync').mockReturnValue(
+      JSON.stringify({ latestVersion: '0.0.6', checkedAt: Date.now() }),
+    );
+    const result = readCachedUpdateInfo('0.0.6');
+    expect(result).toEqual({
+      updateAvailable: false,
+      currentVersion: '0.0.6',
+      latestVersion: '0.0.6',
+    });
+  });
+
+  it('returns null for corrupt JSON', () => {
+    vi.spyOn(fs, 'readFileSync').mockReturnValue('not json{{{');
+    expect(readCachedUpdateInfo('0.0.6')).toBeNull();
+  });
+
+  it('returns null when latestVersion field is missing', () => {
+    vi.spyOn(fs, 'readFileSync').mockReturnValue(
+      JSON.stringify({ checkedAt: Date.now() }),
+    );
+    expect(readCachedUpdateInfo('0.0.6')).toBeNull();
+  });
+});
+
+describe('refreshCacheInBackground', () => {
+  let tmpDir: string;
+  let tmpCacheFile: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'iconwolf-test-'));
+    tmpCacheFile = path.join(tmpDir, 'update-check.json');
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('skips fetch when cache is fresh', async () => {
+    fs.writeFileSync(
+      tmpCacheFile,
+      JSON.stringify({ latestVersion: '0.0.6', checkedAt: Date.now() }),
+    );
+
+    const fetchSpy = vi.spyOn(globalThis, 'fetch');
+    await refreshCacheInBackground(tmpCacheFile);
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it('fetches when cache is stale', async () => {
+    // Write cache with old mtime
+    fs.writeFileSync(
+      tmpCacheFile,
+      JSON.stringify({ latestVersion: '0.0.6', checkedAt: Date.now() }),
+    );
+    // Make it old by setting mtime to 25 hours ago
+    const staleTime = new Date(Date.now() - 25 * 60 * 60 * 1000);
+    fs.utimesSync(tmpCacheFile, staleTime, staleTime);
+
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response(JSON.stringify({ tag_name: 'v0.0.7' }), { status: 200 }),
+    );
+
+    await refreshCacheInBackground(tmpCacheFile);
+
+    const cache = JSON.parse(fs.readFileSync(tmpCacheFile, 'utf-8'));
+    expect(cache.latestVersion).toBe('0.0.7');
+  });
+
+  it('fetches when cache is missing', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response(JSON.stringify({ tag_name: 'v0.0.7' }), { status: 200 }),
+    );
+
+    await refreshCacheInBackground(tmpCacheFile);
+
+    const cache = JSON.parse(fs.readFileSync(tmpCacheFile, 'utf-8'));
+    expect(cache.latestVersion).toBe('0.0.7');
+  });
+
+  it('strips v prefix from tag_name', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response(JSON.stringify({ tag_name: 'v1.2.3' }), { status: 200 }),
+    );
+
+    await refreshCacheInBackground(tmpCacheFile);
+
+    const cache = JSON.parse(fs.readFileSync(tmpCacheFile, 'utf-8'));
+    expect(cache.latestVersion).toBe('1.2.3');
+  });
+
+  it('handles network errors silently', async () => {
+    vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('network fail'));
+
+    await expect(
+      refreshCacheInBackground(tmpCacheFile),
+    ).resolves.toBeUndefined();
+    expect(fs.existsSync(tmpCacheFile)).toBe(false);
+  });
+
+  it('handles non-ok responses silently', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response('Not Found', { status: 404 }),
+    );
+
+    await expect(
+      refreshCacheInBackground(tmpCacheFile),
+    ).resolves.toBeUndefined();
+    expect(fs.existsSync(tmpCacheFile)).toBe(false);
+  });
+
+  it('handles missing tag_name silently', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response(JSON.stringify({}), { status: 200 }),
+    );
+
+    await expect(
+      refreshCacheInBackground(tmpCacheFile),
+    ).resolves.toBeUndefined();
+    expect(fs.existsSync(tmpCacheFile)).toBe(false);
+  });
+});

package/tests/variants/android.test.ts

@@ -0,0 +1,77 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import sharp from 'sharp';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { generateAndroidIcons } from '../../src/variants/android.js';
+import { createTestPng, createTmpDir, cleanDir } from '../helpers.js';
+
+let tmpDir: string;
+let testPng: string;
+
+beforeAll(async () => {
+  tmpDir = createTmpDir();
+  testPng = await createTestPng(1024, 1024, tmpDir);
+});
+
+afterAll(() => {
+  cleanDir(tmpDir);
+});
+
+describe('generateAndroidIcons', () => {
+  it('generates only foreground by default', async () => {
+    const outDir = path.join(tmpDir, 'fg-only');
+    fs.mkdirSync(outDir);
+    const results = await generateAndroidIcons(testPng, outDir, '#FFFFFF');
+
+    expect(results).toHaveLength(1);
+    expect(results[0].width).toBe(1024);
+    expect(results[0].height).toBe(1024);
+    expect(fs.existsSync(results[0].filePath)).toBe(true);
+    expect(path.basename(results[0].filePath)).toBe('adaptive-icon.png');
+  });
+
+  it('generates 3 android icon files with includeBackground', async () => {
+    const outDir = path.join(tmpDir, 'all-android');
+    fs.mkdirSync(outDir);
+    const results = await generateAndroidIcons(testPng, outDir, '#FFFFFF', {
+      includeBackground: true,
+    });
+
+    expect(results).toHaveLength(3);
+
+    for (const result of results) {
+      expect(result.width).toBe(1024);
+      expect(result.height).toBe(1024);
+      expect(fs.existsSync(result.filePath)).toBe(true);
+    }
+  });
+
+  it('names files correctly', async () => {
+    const outDir = path.join(tmpDir, 'names');
+    fs.mkdirSync(outDir);
+    const results = await generateAndroidIcons(testPng, outDir, '#FFFFFF', {
+      includeBackground: true,
+    });
+    const names = results.map((r) => path.basename(r.filePath));
+
+    expect(names).toContain('adaptive-icon.png');
+    expect(names).toContain('android-icon-background.png');
+    expect(names).toContain('monochrome-icon.png');
+  });
+
+  it('background uses the specified color', async () => {
+    const outDir = path.join(tmpDir, 'bg-color');
+    fs.mkdirSync(outDir);
+    const results = await generateAndroidIcons(testPng, outDir, '#FF0000', {
+      includeBackground: true,
+    });
+    const bgResult = results.find((r) => r.filePath.includes('background'));
+
+    expect(bgResult).toBeDefined();
+    const { channels } = await sharp(bgResult!.filePath).stats();
+    // channels[0]=R, [1]=G, [2]=B - check mean values for solid color
+    expect(channels[0].mean).toBeCloseTo(255, -1);
+    expect(channels[1].mean).toBeCloseTo(0, -1);
+    expect(channels[2].mean).toBeCloseTo(0, -1);
+  });
+});

package/tests/variants/favicon.test.ts

@@ -0,0 +1,36 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import sharp from 'sharp';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { generateFavicon } from '../../src/variants/favicon.js';
+import { createTestPng, createTmpDir, cleanDir } from '../helpers.js';
+
+let tmpDir: string;
+let outDir: string;
+let testPng: string;
+
+beforeAll(async () => {
+  tmpDir = createTmpDir();
+  outDir = path.join(tmpDir, 'output');
+  fs.mkdirSync(outDir);
+  testPng = await createTestPng(1024, 1024, tmpDir);
+});
+
+afterAll(() => {
+  cleanDir(tmpDir);
+});
+
+describe('generateFavicon', () => {
+  it('generates favicon.png at 48x48', async () => {
+    const result = await generateFavicon(testPng, outDir);
+
+    expect(result.width).toBe(48);
+    expect(result.height).toBe(48);
+    expect(result.filePath).toContain('favicon.png');
+    expect(fs.existsSync(result.filePath)).toBe(true);
+
+    const meta = await sharp(result.filePath).metadata();
+    expect(meta.format).toBe('png');
+    expect(meta.width).toBe(48);
+  });
+});