#!/usr/bin/env node /** * Rasterizes Pebble notification/timeline icons from a checkout of * https://github.com/pebble-dev/iconography (Apache-2.0) into * app/graphics/pebble-icons-data.ts, for notification sources that come * without an icon of their own (iPhone notifications over ANCS). * * git clone https://github.com/pebble-dev/iconography ~/src/pebble-iconography * node scripts/generate-pebble-icons.cjs ~/src/pebble-iconography [--preview sheet.pgm] * * The 25px icons are drawn black-on-white for Pebble's light screen, on a * 25x25 pixel grid. They are rendered here at 1:1 into 25x25 coverage * bitmaps for a black display: what was ink is lit, and white fills are * dark (painted in order, so a white fill still hides what is under it). * Strokes get round caps and joins, as Pebble's own renderer drew them. * Pixels are quantized to the 0 / 128 / 255 coverage levels the SVG icons * use (SvgIconSource.quantizeCoverage). --preview writes a contact sheet * (4x scale, ICONS order, 10 per row) to check the result by eye. * * Only the SVG subset these icons use is supported (path with * M/L/H/V/C/S/Q/Z, line, polyline, polygon, rect, circle, ellipse; nested * groups with translate/scale/matrix transforms); anything else fails * loudly rather than drawing wrong. */ 'use strict'; const fs = require('node:fs'); const path = require('node:path'); const { execFileSync } = require('node:child_process'); const SIZE = 25; const SUPERSAMPLE = 8; const OUTPUT = path.join(__dirname, '..', 'app', 'graphics', 'pebble-icons-data.ts'); /** Icon name (as the app refers to it) -> source SVG within the iconography checkout. */ const ICONS = { // Generic pictograms, for notification categories and for apps without a brand icon. generic: 'pebbleos/Pebble_25x25_Generic_notification.svg', activity: 'pebbleos/Pebble_25x25_Activity.svg', alarmClock: 'pebbleos/Pebble_25x25_Alarm_clock.svg', appStore: 'icons/25px_Appstore.svg', calendar: 'pebbleos/Pebble_25x25_Calendar.svg', car: 'pebbleos/Pebble_25x25_Car_rental.svg', contacts: 'icons/25px_Contacts_book.svg', dinner: 'pebbleos/Pebble_25x25_Dinner_reservation.svg', email: 'pebbleos/Pebble_25x25_Generic_e-mail.svg', flight: 'pebbleos/Pebble_25x25_Scheduled_flight.svg', glucose: 'pebbleos/Pebble_25x25_Glucose_monitor.svg', heart: 'pebbleos/Pebble_25x25_Heart.svg', incomingCall: 'pebbleos/Pebble_25x25_Incoming_call.svg', location: 'pebbleos/Pebble_25x25_Location.svg', microphone: 'icons/25px_Microphone.svg', missedCall: 'pebbleos/Pebble_25x25_Missed_call.svg', movie: 'pebbleos/Pebble_25x25_Movie_event.svg', music: 'icons/25px_Music_note.svg', news: 'pebbleos/Pebble_25x25_News_event.svg', payBill: 'pebbleos/Pebble_25x25_Pay_bill.svg', phone: 'pebbleos/Pebble_25x25_During_phone_call.svg', podcast: 'pebbleos/Pebble_25x25_Radio_show.svg', reminder: 'pebbleos/Pebble_25x25_Generic_reminder.svg', settings: 'pebbleos/Pebble_25x25_Settings.svg', shopping: 'icons/25px_Shopping_bag.svg', sms: 'icons/25px_SMS.svg', stocks: 'pebbleos/Pebble_25x25_Stocks_event.svg', tv: 'pebbleos/Pebble_25x25_TV_show.svg', voicemail: 'icons/25px_Phone.svg', warning: 'pebbleos/Pebble_25x25_Generic_warning.svg', weather: 'pebbleos/Pebble_25x25_Generic_weather.svg', // Brands. airmail: 'brand-logos/Airmail_25px.svg', amazon: 'pebbleos/Pebble_25x25_Amazon.svg', appleShortcuts: 'brand-logos/Apple_Shortcuts_25px.svg', bbcNews: 'brand-logos/BBC_News_25px.svg', beeper: 'brand-logos/Beeper_25px.svg', bluesky: 'brand-logos/Bluesky_25px.svg', discord: 'brand-logos/Discord_25px.svg', duolingo: 'brand-logos/Duolingo_25px.svg', ebay: 'brand-logos/eBay_25px.svg', element: 'brand-logos/Element_25px.svg', facebook: 'pebbleos/Pebble_25x25_Facebook_notification.svg', facetime: 'pebbleos/Pebble_25x25_Facetime_incoming.svg', gmail: 'pebbleos/Pebble_25x25_Gmail_notification.svg', googleChat: 'brand-logos/Google_Chat_25px.svg', googleMaps: 'pebbleos/Pebble_25x25_Google_Maps.svg', googlePhotos: 'pebbleos/Pebble_25x25_Google_Photos.svg', googleTasks: 'brand-logos/Google_Tasks_25px.svg', homeAssistant: 'brand-logos/Home_Assistant_25px.svg', instagram: 'pebbleos/Pebble_25x25_Instagram.svg', iosPhotos: 'pebbleos/Pebble_25x25_iOS_Photos.svg', kakaoTalk: 'pebbleos/Pebble_25x25_KakaoTalk.svg', kik: 'pebbleos/Pebble_25x25_Kik.svg', line: 'pebbleos/Pebble_25x25_Line.svg', linkedIn: 'pebbleos/Pebble_25x25_LinkedIn.svg', messenger: 'pebbleos/Pebble_25x25_Facebook_messenger_notification.svg', omniFocus: 'brand-logos/OmniFocus_25px.svg', outlook: 'brand-logos/Outlook_25px.svg', reddit: 'brand-logos/Reddit_25px.svg', signal: 'brand-logos/Signal_25px.svg', simplex: 'brand-logos/SimpleX_25px.svg', slack: 'pebbleos/Pebble_25x25_Slack.svg', snapchat: 'pebbleos/Pebble_25x25_Snapchat.svg', steam: 'brand-logos/Steam_25px.svg', substack: 'brand-logos/Substack_25px.svg', swarm: 'brand-logos/Swarm_25px.svg', tapo: 'brand-logos/Tapo_25px.svg', teams: 'brand-logos/Teams_25px.svg', telegram: 'pebbleos/Pebble_25x25_Telegram_app.svg', threads: 'brand-logos/Threads_25px.svg', tiktok: 'brand-logos/TikTok_25px.svg', twitch: 'brand-logos/Twitch_25px.svg', twitter: 'pebbleos/Pebble_25x25_Twitter_notification.svg', unifiProtect: 'brand-logos/Unifi_Protect_25px.svg', viber: 'pebbleos/Pebble_25x25_Viber.svg', waze: 'brand-logos/Waze_25px.svg', weChat: 'pebbleos/Pebble_25x25_WeChat.svg', whatsApp: 'pebbleos/Pebble_25x25_WhatsApp_notification.svg', whatsAppBusiness: 'brand-logos/WhatsApp_Business_25px.svg', yahooMail: 'pebbleos/Pebble_25x25_Yahoo_mail.svg', youtube: 'brand-logos/Youtube_25px.svg', zoom: 'brand-logos/Zoom_25px.svg', }; // ----- XML ----------------------------------------------------------------- /** A minimal well-formed-XML reader: elements and attributes; text, comments and PIs are skipped. */ function parseXml(text) { const root = { tag: '#document', attrs: {}, children: [] }; const stack = [root]; const token = /|<\?[\s\S]*?\?>|||<\/([^\s>]+)\s*>|<([^\s/>!?]+)((?:\s+[^\s=/>]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>/g; let match; while ((match = token.exec(text))) { if (match[1]) { const open = stack.pop(); if (!open || open.tag !== match[1]) throw new Error(`mismatched `); } else if (match[2]) { const attrs = {}; for (const a of match[3].matchAll(/([^\s=]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) attrs[a[1]] = a[2] ?? a[3]; const element = { tag: match[2], attrs, children: [] }; stack[stack.length - 1].children.push(element); if (!match[4]) stack.push(element); } } if (stack.length !== 1) throw new Error(`unclosed <${stack[stack.length - 1].tag}>`); const svg = root.children.find((child) => child.tag === 'svg'); if (!svg) throw new Error('no element'); return svg; } // ----- Styles and transforms ----------------------------------------------- const INHERITED = ['fill', 'stroke', 'stroke-width', 'fill-opacity', 'stroke-opacity', 'fill-rule']; /** Presentation attributes overlaid by the style attribute (which wins, as in CSS). */ function ownStyle(element) { const style = { ...element.attrs }; for (const part of (element.attrs.style ?? '').split(';')) { const colon = part.indexOf(':'); if (colon > 0) style[part.slice(0, colon).trim()] = part.slice(colon + 1).trim(); } return style; } const IDENTITY = [1, 0, 0, 1, 0, 0]; function multiply(m, n) { return [ m[0] * n[0] + m[2] * n[1], m[1] * n[0] + m[3] * n[1], m[0] * n[2] + m[2] * n[3], m[1] * n[2] + m[3] * n[3], m[0] * n[4] + m[2] * n[5] + m[4], m[1] * n[4] + m[3] * n[5] + m[5], ]; } function parseTransform(text) { let m = IDENTITY; if (!text) return m; for (const [, name, args] of text.matchAll(/(\w+)\s*\(([^)]*)\)/g)) { const v = args.split(/[\s,]+/).filter(Boolean).map(Number); if (name === 'translate') m = multiply(m, [1, 0, 0, 1, v[0], v[1] ?? 0]); else if (name === 'scale') m = multiply(m, [v[0], 0, 0, v[1] ?? v[0], 0, 0]); else if (name === 'matrix' && v.length === 6) m = multiply(m, v); else throw new Error(`unsupported transform ${name}(${args})`); } return m; } /** 0 (white) .. 1 (black): how lit a color's ink is once the icon is inverted. */ function inkOf(color) { if (!color || color === 'none' || color === 'transparent') return null; const named = { black: '#000000', white: '#ffffff', currentcolor: '#000000' }; let hex = named[color.toLowerCase()] ?? color; if (/^#[0-9a-f]{3}$/i.test(hex)) hex = '#' + [...hex.slice(1)].map((c) => c + c).join(''); if (!/^#[0-9a-f]{6}$/i.test(hex)) throw new Error(`unsupported color ${color}`); const n = parseInt(hex.slice(1), 16); const luminance = (0.2126 * ((n >> 16) & 255) + 0.7152 * ((n >> 8) & 255) + 0.0722 * (n & 255)) / 255; return 1 - luminance; } // ----- Geometry ------------------------------------------------------------ const CURVE_STEPS = 16; const ARC_STEPS = 48; /** Subpaths ({ points: [[x, y], ...], closed }) in the element's own coordinates. */ function shapeOf(element) { const a = element.attrs; const num = (name, fallback = 0) => (a[name] === undefined ? fallback : parseFloat(a[name])); switch (element.tag) { case 'path': return pathSubpaths(a.d ?? ''); case 'line': return [{ points: [[num('x1'), num('y1')], [num('x2'), num('y2')]], closed: false }]; case 'polyline': case 'polygon': { const v = (a.points ?? '').trim().split(/[\s,]+/).filter(Boolean).map(Number); const points = []; for (let i = 0; i + 1 < v.length; i += 2) points.push([v[i], v[i + 1]]); return points.length ? [{ points, closed: element.tag === 'polygon' }] : []; } case 'rect': { const x = num('x'), y = num('y'), w = num('width'), h = num('height'); let rx = a.rx === undefined ? num('ry') : num('rx'); let ry = a.ry === undefined ? rx : num('ry'); rx = Math.min(rx, w / 2); ry = Math.min(ry, h / 2); if (w <= 0 || h <= 0) return []; if (rx <= 0 || ry <= 0) return [{ points: [[x, y], [x + w, y], [x + w, y + h], [x, y + h]], closed: true }]; const points = []; const corners = [[x + w - rx, y + ry, -90], [x + w - rx, y + h - ry, 0], [x + rx, y + h - ry, 90], [x + rx, y + ry, 180]]; for (const [cx, cy, start] of corners) { for (let i = 0; i <= ARC_STEPS / 4; i++) { const t = ((start + (90 * i) / (ARC_STEPS / 4)) * Math.PI) / 180; points.push([cx + rx * Math.cos(t), cy + ry * Math.sin(t)]); } } return [{ points, closed: true }]; } case 'circle': case 'ellipse': { const rx = element.tag === 'circle' ? num('r') : num('rx'); const ry = element.tag === 'circle' ? num('r') : num('ry'); if (rx <= 0 || ry <= 0) return []; const points = []; for (let i = 0; i < ARC_STEPS; i++) { const t = (2 * Math.PI * i) / ARC_STEPS; points.push([num('cx') + rx * Math.cos(t), num('cy') + ry * Math.sin(t)]); } return [{ points, closed: true }]; } default: return null; } } function pathSubpaths(d) { const tokens = d.match(/[A-Za-z]|[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g) ?? []; const subpaths = []; let current = null; let x = 0, y = 0, startX = 0, startY = 0; let lastControl = null; let command = ''; let i = 0; const next = () => { if (i >= tokens.length || /[A-Za-z]/.test(tokens[i])) throw new Error(`path data ends early: ${d}`); return Number(tokens[i++]); }; const lineTo = (nx, ny) => { current.points.push([nx, ny]); x = nx; y = ny; }; const cubic = (x1, y1, x2, y2, x3, y3) => { const [x0, y0] = [x, y]; for (let s = 1; s <= CURVE_STEPS; s++) { const t = s / CURVE_STEPS, u = 1 - t; current.points.push([ u * u * u * x0 + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x3, u * u * u * y0 + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y3, ]); } x = x3; y = y3; lastControl = [x2, y2]; }; while (i < tokens.length) { if (/[A-Za-z]/.test(tokens[i])) command = tokens[i++]; else if (!command) throw new Error(`path data starts without a command: ${d}`); const rel = command === command.toLowerCase(); const ox = rel ? x : 0, oy = rel ? y : 0; const upper = command.toUpperCase(); if (upper !== 'C' && upper !== 'S') lastControl = null; switch (upper) { case 'M': { const nx = ox + next(), ny = oy + next(); current = { points: [[nx, ny]], closed: false }; subpaths.push(current); x = startX = nx; y = startY = ny; command = rel ? 'l' : 'L'; // further pairs are implicit line-tos break; } case 'L': lineTo(ox + next(), oy + next()); break; case 'H': lineTo(ox + next(), y); break; case 'V': lineTo(x, oy + next()); break; case 'C': cubic(ox + next(), oy + next(), ox + next(), oy + next(), ox + next(), oy + next()); break; case 'S': { const [cx, cy] = lastControl ? [2 * x - lastControl[0], 2 * y - lastControl[1]] : [x, y]; cubic(cx, cy, ox + next(), oy + next(), ox + next(), oy + next()); break; } case 'Q': { const qx = ox + next(), qy = oy + next(), ex = ox + next(), ey = oy + next(); cubic(x + (2 / 3) * (qx - x), y + (2 / 3) * (qy - y), ex + (2 / 3) * (qx - ex), ey + (2 / 3) * (qy - ey), ex, ey); lastControl = null; break; } case 'Z': if (current) current.closed = true; x = startX; y = startY; // A drawing command straight after Z starts a new subpath at the start point. current = { points: [[x, y]], closed: false }; subpaths.push(current); command = ''; break; default: throw new Error(`unsupported path command ${command} in ${d}`); } } return subpaths.filter((subpath) => subpath.points.length > 1 || subpath.closed); } // ----- Rasterization ------------------------------------------------------- const GRID = SIZE * SUPERSAMPLE; /** Mark the samples a shape's fill covers (scanline crossings, nonzero or evenodd). */ function fillMask(subpaths, evenOdd) { const mask = new Uint8Array(GRID * GRID); const edges = []; for (const { points } of subpaths) { for (let k = 0; k < points.length; k++) { const [x0, y0] = points[k], [x1, y1] = points[(k + 1) % points.length]; if (y0 !== y1) edges.push([x0, y0, x1, y1]); } } for (let row = 0; row < GRID; row++) { const sy = (row + 0.5) / SUPERSAMPLE; const crossings = []; for (const [x0, y0, x1, y1] of edges) { if ((sy >= y0 && sy < y1) || (sy >= y1 && sy < y0)) { crossings.push([x0 + ((sy - y0) * (x1 - x0)) / (y1 - y0), y1 > y0 ? 1 : -1]); } } crossings.sort((p, q) => p[0] - q[0]); let winding = 0; for (let k = 0; k + 1 < crossings.length; k++) { winding += crossings[k][1]; const inside = evenOdd ? (k + 1) % 2 === 1 : winding !== 0; if (!inside) continue; const from = Math.max(0, Math.ceil(crossings[k][0] * SUPERSAMPLE - 0.5)); const to = Math.min(GRID - 1, Math.floor(crossings[k + 1][0] * SUPERSAMPLE - 0.5)); for (let col = from; col <= to; col++) mask[row * GRID + col] = 1; } } return mask; } /** Mark the samples within half the stroke width of any segment: round caps and joins. */ function strokeMask(subpaths, width) { const mask = new Uint8Array(GRID * GRID); const half = width / 2; const segment = (x0, y0, x1, y1) => { const minCol = Math.max(0, Math.floor((Math.min(x0, x1) - half) * SUPERSAMPLE)); const maxCol = Math.min(GRID - 1, Math.ceil((Math.max(x0, x1) + half) * SUPERSAMPLE)); const minRow = Math.max(0, Math.floor((Math.min(y0, y1) - half) * SUPERSAMPLE)); const maxRow = Math.min(GRID - 1, Math.ceil((Math.max(y0, y1) + half) * SUPERSAMPLE)); const dx = x1 - x0, dy = y1 - y0, length2 = dx * dx + dy * dy; for (let row = minRow; row <= maxRow; row++) { const sy = (row + 0.5) / SUPERSAMPLE; for (let col = minCol; col <= maxCol; col++) { const sx = (col + 0.5) / SUPERSAMPLE; const t = length2 ? Math.max(0, Math.min(1, ((sx - x0) * dx + (sy - y0) * dy) / length2)) : 0; const ex = sx - (x0 + t * dx), ey = sy - (y0 + t * dy); if (ex * ex + ey * ey <= half * half) mask[row * GRID + col] = 1; } } }; for (const { points, closed } of subpaths) { if (points.length === 1) segment(points[0][0], points[0][1], points[0][0], points[0][1]); for (let k = 0; k + 1 < points.length; k++) segment(...points[k], ...points[k + 1]); if (closed && points.length > 2) segment(...points[points.length - 1], ...points[0]); } return mask; } function composite(ink, mask, value, alpha) { for (let k = 0; k < ink.length; k++) if (mask[k]) ink[k] = ink[k] * (1 - alpha) + value * alpha; } /** Render one SVG source to SIZE x SIZE coverage values (0..255, quantized). */ function renderIcon(svgText) { const svg = parseXml(svgText); const viewBox = (svg.attrs.viewBox ?? `0 0 ${SIZE} ${SIZE}`).trim().split(/[\s,]+/).map(Number); const [minX, minY, vw, vh] = viewBox; // 1:1 keeps the icons' pixel-grid strokes crisp; larger art scales down. const scale = Math.min(1, SIZE / vw, SIZE / vh); const offsetX = scale === 1 ? Math.round((SIZE - vw) / 2) : (SIZE - vw * scale) / 2; const offsetY = scale === 1 ? Math.round((SIZE - vh) / 2) : (SIZE - vh * scale) / 2; const base = [scale, 0, 0, scale, offsetX - minX * scale, offsetY - minY * scale]; const ink = new Float32Array(GRID * GRID); const walk = (element, inherited, matrix, opacity) => { const own = ownStyle(element); if (own.display === 'none' || own.visibility === 'hidden') return; const style = { ...inherited }; for (const key of INHERITED) if (own[key] !== undefined) style[key] = own[key]; const m = multiply(matrix, parseTransform(element.attrs.transform)); const alpha = opacity * (own.opacity === undefined ? 1 : parseFloat(own.opacity)); if (element.tag === 'svg' || element.tag === 'g') { for (const child of element.children) walk(child, style, m, alpha); return; } const subpaths = shapeOf(element); if (subpaths === null) { // Not drawn: definitions, editor metadata, and the stray embedded // reference bitmap in one export (Pebble's converter skips them too). if (['defs', 'clipPath', 'mask', 'title', 'desc', 'metadata', 'image', 'style'].includes(element.tag) || element.tag.includes(':')) return; throw new Error(`unsupported element <${element.tag}>`); } const placed = subpaths.map(({ points, closed }) => ({ closed, points: points.map(([px, py]) => [m[0] * px + m[2] * py + m[4], m[1] * px + m[3] * py + m[5]]), })); const fill = inkOf(style.fill ?? 'black'); if (fill !== null) { const fillAlpha = alpha * parseFloat(style['fill-opacity'] ?? '1'); composite(ink, fillMask(placed, style['fill-rule'] === 'evenodd'), fill, fillAlpha); } const stroke = inkOf(style.stroke); const width = parseFloat(style['stroke-width'] ?? '1') * Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])); if (stroke !== null && width > 0) { const strokeAlpha = alpha * parseFloat(style['stroke-opacity'] ?? '1'); composite(ink, strokeMask(placed, width), stroke, strokeAlpha); } }; walk(svg, {}, base, 1); const pixels = new Uint8Array(SIZE * SIZE); for (let py = 0; py < SIZE; py++) { for (let px = 0; px < SIZE; px++) { let sum = 0; for (let sy = 0; sy < SUPERSAMPLE; sy++) { for (let sx = 0; sx < SUPERSAMPLE; sx++) sum += ink[(py * SUPERSAMPLE + sy) * GRID + px * SUPERSAMPLE + sx]; } const coverage = (sum / (SUPERSAMPLE * SUPERSAMPLE)) * 255; pixels[py * SIZE + px] = coverage < 64 ? 0 : coverage >= 192 ? 255 : 128; } } return pixels; } // ----- Output -------------------------------------------------------------- const LEVEL_CODES = { 0: 0, 128: 1, 255: 2 }; /** 2 bits per pixel (0 / 128 / 255), four pixels per byte, high bits first; base64. */ function encode(pixels) { const bytes = Buffer.alloc(Math.ceil(pixels.length / 4)); for (let k = 0; k < pixels.length; k++) bytes[k >> 2] |= LEVEL_CODES[pixels[k]] << (6 - 2 * (k & 3)); return bytes.toString('base64'); } function writePreview(file, rendered) { const SCALE = 4, CELL = (SIZE + 4) * SCALE, COLUMNS = 10; const rows = Math.ceil(rendered.length / COLUMNS); const width = COLUMNS * CELL, height = rows * CELL; const image = Buffer.alloc(width * height, 40); rendered.forEach(({ pixels }, index) => { const left = (index % COLUMNS) * CELL + 2 * SCALE, top = Math.floor(index / COLUMNS) * CELL + 2 * SCALE; for (let y = 0; y < SIZE * SCALE; y++) { for (let x = 0; x < SIZE * SCALE; x++) { image[(top + y) * width + left + x] = pixels[Math.floor(y / SCALE) * SIZE + Math.floor(x / SCALE)]; } } }); fs.writeFileSync(file, Buffer.concat([Buffer.from(`P5\n${width} ${height}\n255\n`), image])); } function main() { const args = process.argv.slice(2); const previewAt = args.indexOf('--preview'); const preview = previewAt >= 0 ? args.splice(previewAt, 2)[1] : null; const checkout = args[0]; if (!checkout) { console.error('usage: generate-pebble-icons.cjs [--preview sheet.pgm]'); process.exit(2); } const commit = execFileSync('git', ['-C', checkout, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim(); const rendered = Object.entries(ICONS).map(([name, source]) => { try { return { name, source, pixels: renderIcon(fs.readFileSync(path.join(checkout, source), 'utf8')) }; } catch (error) { throw new Error(`${source}: ${error.message}`); } }); const lines = [ '// Generated by scripts/generate-pebble-icons.cjs; do not edit by hand.', '//', '// Pebble notification icons from https://github.com/pebble-dev/iconography', `// (commit ${commit}): the original Pebble Technology icons and`, '// Rebble community additions, licensed under the Apache License 2.0 (see', '// app/graphics/pebble-icons.LICENSE). Modified: rasterized at 25x25 and', '// inverted for a black display (Pebble draws them black on white).', '//', '// Each icon is SIZE x SIZE pixels at 2 bits each (0, 1, 2 = coverage 0,', '// 128, 255), four pixels to a byte with the first in the high bits,', '// row-major, base64-encoded.', '', `export const PEBBLE_ICON_SIZE = ${SIZE};`, '', 'export const PEBBLE_ICON_DATA = {', ...rendered.map(({ name, source, pixels }) => ` ${name}: "${encode(pixels)}", // ${source}`), '} as const;', '', 'export type PebbleIconName = keyof typeof PEBBLE_ICON_DATA;', '', ]; fs.writeFileSync(OUTPUT, lines.join('\n')); console.log(`wrote ${rendered.length} icons to ${path.relative(process.cwd(), OUTPUT)}`); if (preview) { writePreview(preview, rendered); console.log(`preview: ${preview}`); rendered.forEach(({ name }, index) => process.stdout.write(`${index % 10 === 0 ? '\n' : ' '}${name}`)); process.stdout.write('\n'); } } if (require.main === module) main(); module.exports = { renderIcon, encode, ICONS, SIZE };