imgico 0.1.3

High-performance image to ICO/SVG converter with WebAssembly support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use base64::{engine::general_purpose, Engine as _};
use image::ImageOutputFormat;
use std::io::{Cursor, Write};
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn set_panic_hook() {
    console_error_panic_hook::set_once();
}

const DEFAULT_SIZES: [u32; 6] = [16, 32, 48, 64, 128, 256];

pub fn imgico_core(input: &[u8], sizes: Option<Vec<u32>>) -> Result<Vec<u8>, String> {
    let sizes = sizes.unwrap_or_else(|| DEFAULT_SIZES.to_vec());
    let img = image::load_from_memory(input).map_err(|e| format!("Failed to load image: {}", e))?;

    let mut images = Vec::new();

    for size in sizes {
        if size < 1 || size > 256 {
            return Err(format!(
                "Invalid icon size: {}. Size must be between 1 and 256.",
                size
            ));
        }

        // Make square by cropping from center
        let (width, height) = (img.width(), img.height());
        let min_dim = width.min(height);
        let x_offset = (width - min_dim) / 2;
        let y_offset = (height - min_dim) / 2;

        let square_img = img.crop_imm(x_offset, y_offset, min_dim, min_dim);

        // Resize to exact dimensions (no aspect ratio preservation)
        let resized = square_img.resize_exact(size, size, image::imageops::FilterType::Lanczos3);

        let mut buffer = Cursor::new(Vec::new());
        resized
            .write_to(&mut buffer, ImageOutputFormat::Png)
            .map_err(|e| format!("Failed to write PNG: {}", e))?;

        images.push((buffer.into_inner(), size));
    }

    // Create ICO header
    let mut ico_data = Vec::new();

    // Header
    ico_data.write_all(&0u16.to_le_bytes()).unwrap(); // Reserved
    ico_data.write_all(&1u16.to_le_bytes()).unwrap(); // Type (1 = ICO)
    ico_data
        .write_all(&(images.len() as u16).to_le_bytes())
        .unwrap(); // Count

    let directory_size = 16 * images.len();
    let mut offset = 6 + directory_size;

    // Directory Entries
    for (buffer, size) in &images {
        let dim = if *size >= 256 { 0 } else { *size as u8 };
        ico_data.write_all(&[dim]).unwrap(); // Width
        ico_data.write_all(&[dim]).unwrap(); // Height
        ico_data.write_all(&[0]).unwrap(); // Palette count
        ico_data.write_all(&[0]).unwrap(); // Reserved
        ico_data.write_all(&1u16.to_le_bytes()).unwrap(); // Color planes
        ico_data.write_all(&32u16.to_le_bytes()).unwrap(); // Bits per pixel
        ico_data
            .write_all(&(buffer.len() as u32).to_le_bytes())
            .unwrap(); // Size
        ico_data.write_all(&(offset as u32).to_le_bytes()).unwrap(); // Offset

        offset += buffer.len();
    }

    // Image Data
    for (buffer, _) in images {
        ico_data.write_all(&buffer).unwrap();
    }

    Ok(ico_data)
}

#[wasm_bindgen]
pub fn imgico(input: &[u8], sizes: Option<Vec<u32>>) -> Result<Vec<u8>, JsValue> {
    imgico_core(input, sizes).map_err(|e| JsValue::from_str(&e))
}

pub fn imgsvg_core(input: &[u8], size: Option<u32>) -> Result<Vec<u8>, String> {
    let img = image::load_from_memory(input).map_err(|e| format!("Failed to load image: {}", e))?;

    let final_img = if let Some(s) = size {
        // Make square by cropping from center
        let (width, height) = (img.width(), img.height());
        let min_dim = width.min(height);
        let x_offset = (width - min_dim) / 2;
        let y_offset = (height - min_dim) / 2;

        let square_img = img.crop_imm(x_offset, y_offset, min_dim, min_dim);
        square_img.resize_exact(s, s, image::imageops::FilterType::Lanczos3)
    } else {
        img
    };

    let mut buffer = Cursor::new(Vec::new());
    final_img
        .write_to(&mut buffer, ImageOutputFormat::Png)
        .map_err(|e| format!("Failed to write PNG: {}", e))?;

    let png_data = buffer.into_inner();
    let width = final_img.width();
    let height = final_img.height();

    let b64 = general_purpose::STANDARD.encode(&png_data);

    let svg = format!(
        r#"<svg width="{}" height="{}" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
  <image width="{}" height="{}" xlink:href="data:image/png;base64,{}" />
</svg>"#,
        width, height, width, height, b64
    );

    Ok(svg.into_bytes())
}

#[wasm_bindgen]
pub fn imgsvg(input: &[u8], size: Option<u32>) -> Result<Vec<u8>, JsValue> {
    imgsvg_core(input, size).map_err(|e| JsValue::from_str(&e))
}

pub fn imgpng_core(input: &[u8], size: Option<u32>) -> Result<Vec<u8>, String> {
    let img = image::load_from_memory(input).map_err(|e| format!("Failed to load image: {}", e))?;

    let final_img = if let Some(s) = size {
        // Make square by cropping from center
        let (width, height) = (img.width(), img.height());
        let min_dim = width.min(height);
        let x_offset = (width - min_dim) / 2;
        let y_offset = (height - min_dim) / 2;

        let square_img = img.crop_imm(x_offset, y_offset, min_dim, min_dim);
        square_img.resize_exact(s, s, image::imageops::FilterType::Lanczos3)
    } else {
        img
    };

    let mut buffer = Cursor::new(Vec::new());
    final_img
        .write_to(&mut buffer, ImageOutputFormat::Png)
        .map_err(|e| format!("Failed to write PNG: {}", e))?;

    Ok(buffer.into_inner())
}

#[wasm_bindgen]
pub fn imgpng(input: &[u8], size: Option<u32>) -> Result<Vec<u8>, JsValue> {
    imgpng_core(input, size).map_err(|e| JsValue::from_str(&e))
}