react-native-nano-icons 0.1.1 → 0.1.3

package/lib/commonjs/cli/config.js

@@ -7,19 +7,20 @@ exports.loadNanoIconsConfig = loadNanoIconsConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 /**
- * Load .nanoicons.json from the project root.
+ * Load .nanoicons.json from the given directory.
  * Throws with a helpful message if the file is missing or malformed.
  */
-function loadNanoIconsConfig(projectRoot) {
-    const configPath = node_path_1.default.join(projectRoot, '.nanoicons.json');
+function loadNanoIconsConfig(configRoot) {
+    const configPath = node_path_1.default.join(configRoot, '.nanoicons.json');
     if (!node_fs_1.default.existsSync(configPath)) {
-        throw new Error(`[react-native-nano-icons] No .nanoicons.json found at project root (${projectRoot}).\n` +
-            `Create one with: { "iconSets": [{ "inputDir": "assets/icons", "fontFamily": "MyIcons" }] }`);
+        throw new Error(`🔬❌ [react-native-nano-icons] No .nanoicons.json found at (${configRoot}).\n` +
+            `Create one with: { "iconSets": [{ "inputDir": "assets/icons", "fontFamily": "MyIcons" }] } \n` +
+            `Or run with --path <dir> to specify a different directory.`);
     }
     const raw = node_fs_1.default.readFileSync(configPath, 'utf8');
     const config = JSON.parse(raw);
     if (!config?.iconSets?.length) {
-        throw new Error(`[react-native-nano-icons] .nanoicons.json must contain an "iconSets" array with at least one entry.`);
+        throw new Error(`🔬❌ [react-native-nano-icons] .nanoicons.json must contain an "iconSets" array with at least one entry.`);
     }
     return config;
 }

package/lib/commonjs/plugin/src/buildFonts.d.ts

@@ -5,3 +5,4 @@ import type { IconSetConfig, BuiltFont } from './types.js';
  * unless EXPO_DEBUG is set, in which case the full error is re-thrown.
  */
 export declare function buildAllFonts(iconSets: IconSetConfig[], projectRoot: string): Promise<BuiltFont[]>;
+export declare function getOrBuildFonts(projectRoot: string, iconSets: IconSetConfig[]): Promise<BuiltFont[]>;

package/lib/commonjs/plugin/src/buildFonts.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildAllFonts = buildAllFonts;
+exports.getOrBuildFonts = getOrBuildFonts;
 const index_js_1 = require("../../cli/index.js");
 /**
  * Build TTF + glyphmap for all icon sets.
@@ -21,3 +22,11 @@ async function buildAllFonts(iconSets, projectRoot) {
         return [];
     }
 }
+// Single build run per process; reused across ios/android mods.
+let _buildPromise = null;
+function getOrBuildFonts(projectRoot, iconSets) {
+    if (!_buildPromise) {
+        _buildPromise = buildAllFonts(iconSets, projectRoot);
+    }
+    return _buildPromise;
+}

package/lib/commonjs/plugin/src/index.js

@@ -1,43 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const config_plugins_1 = require("@expo/config-plugins");
-const buildFonts_js_1 = require("./buildFonts.js");
 const withNanoIconsFontLinking_js_1 = require("./withNanoIconsFontLinking.js");
-const BUILT_FONTS_KEY = '_nanoIconsBuilt';
-// Single Pyodide/PathKit run for the whole prebuild; reused across ios/android mods.
-let _builtFontsCache = null;
-function getOrBuildFonts(projectRoot, iconSets) {
-    if (_builtFontsCache)
-        return Promise.resolve(_builtFontsCache);
-    return (0, buildFonts_js_1.buildAllFonts)(iconSets, projectRoot).then((built) => {
-        _builtFontsCache = built;
-        return built;
-    });
-}
 const withNanoIcons = (config, options) => {
     if (!options?.iconSets?.length)
         return config;
-    // Build fonts (once per process, cached) and attach to config for linking mods.
-    config = (0, config_plugins_1.withDangerousMod)(config, [
-        'ios',
-        async (config) => {
-            const projectRoot = config.modRequest.projectRoot;
-            const built = await getOrBuildFonts(projectRoot, options.iconSets);
-            config[BUILT_FONTS_KEY] = built;
-            return config;
-        },
-    ]);
-    config = (0, config_plugins_1.withDangerousMod)(config, [
-        'android',
-        async (config) => {
-            const projectRoot = config.modRequest.projectRoot;
-            const built = await getOrBuildFonts(projectRoot, options.iconSets);
-            config[BUILT_FONTS_KEY] = built;
-            return config;
-        },
-    ]);
-    // Link built TTFs into native projects (reads _nanoIconsBuilt from config).
-    config = (0, withNanoIconsFontLinking_js_1.withNanoIconsFontLinking)(config);
+    config = (0, withNanoIconsFontLinking_js_1.withNanoIconsFontLinking)(config, options.iconSets);
     return config;
 };
 exports.default = withNanoIcons;

package/lib/commonjs/plugin/src/withNanoIconsFontLinking.d.ts

@@ -1,14 +1,14 @@
 import { withXcodeProject, withDangerousMod } from '@expo/config-plugins';
+import type { IconSetConfig } from './types.js';
 /**
  * Add TTFs to the iOS project (Resources group + UIAppFonts in Info.plist).
- * Reads cached built font paths from config._nanoIconsBuilt (set by the build mod) to prevent redundant builds for iOS and Android.
  */
-export declare function withNanoIconsIos(config: Parameters<typeof withXcodeProject>[0]): ReturnType<typeof withXcodeProject>;
+export declare function withNanoIconsIos(config: Parameters<typeof withXcodeProject>[0], iconSets: IconSetConfig[]): ReturnType<typeof withXcodeProject>;
 /**
- * Copy TTFs to Android assets/fonts. Reads paths from config._nanoIconsBuilt.
+ * Copy TTFs to Android assets/fonts.
  */
-export declare function withNanoIconsAndroid(config: Parameters<typeof withDangerousMod>[0]): ReturnType<typeof withDangerousMod>;
+export declare function withNanoIconsAndroid(config: Parameters<typeof withDangerousMod>[0], iconSets: IconSetConfig[]): ReturnType<typeof withDangerousMod>;
 /**
- * Apply iOS and Android font linking. Built font list is read from config (set by build mod).
+ * Apply iOS and Android font linking.
  */
-export declare function withNanoIconsFontLinking(config: Parameters<typeof withNanoIconsIos>[0]): ReturnType<typeof withNanoIconsAndroid>;
+export declare function withNanoIconsFontLinking(config: Parameters<typeof withNanoIconsIos>[0], iconSets: IconSetConfig[]): ReturnType<typeof withNanoIconsAndroid>;

package/lib/commonjs/plugin/src/withNanoIconsFontLinking.js

@@ -9,18 +9,14 @@ exports.withNanoIconsFontLinking = withNanoIconsFontLinking;
 const config_plugins_1 = require("@expo/config-plugins");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
+const buildFonts_js_1 = require("./buildFonts.js");
 const ANDROID_ASSETS_FONTS_DIR = 'app/src/main/assets/fonts';
-const BUILT_FONTS_KEY = '_nanoIconsBuilt';
-function getBuiltFonts(config) {
-    return config[BUILT_FONTS_KEY];
-}
 /**
  * Add TTFs to the iOS project (Resources group + UIAppFonts in Info.plist).
- * Reads cached built font paths from config._nanoIconsBuilt (set by the build mod) to prevent redundant builds for iOS and Android.
  */
-function withNanoIconsIos(config) {
+function withNanoIconsIos(config, iconSets) {
     config = (0, config_plugins_1.withXcodeProject)(config, async (config) => {
-        const built = getBuiltFonts(config);
+        const built = await (0, buildFonts_js_1.getOrBuildFonts)(config.modRequest.projectRoot, iconSets);
         if (!built?.length)
             return config;
         const ttfPaths = built.map((b) => b.ttfPath);
@@ -40,7 +36,7 @@ function withNanoIconsIos(config) {
         return config;
     });
     config = (0, config_plugins_1.withInfoPlist)(config, async (config) => {
-        const built = getBuiltFonts(config);
+        const built = await (0, buildFonts_js_1.getOrBuildFonts)(config.modRequest.projectRoot, iconSets);
         if (!built?.length)
             return config;
         const ttfPaths = built.map((b) => b.ttfPath);
@@ -62,13 +58,13 @@ function getUIAppFonts(infoPlist) {
     return [];
 }
 /**
- * Copy TTFs to Android assets/fonts. Reads paths from config._nanoIconsBuilt.
+ * Copy TTFs to Android assets/fonts.
  */
-function withNanoIconsAndroid(config) {
+function withNanoIconsAndroid(config, iconSets) {
     return (0, config_plugins_1.withDangerousMod)(config, [
         'android',
         async (config) => {
-            const built = getBuiltFonts(config);
+            const built = await (0, buildFonts_js_1.getOrBuildFonts)(config.modRequest.projectRoot, iconSets);
             if (!built?.length)
                 return config;
             const fontsDir = path_1.default.join(config.modRequest.platformProjectRoot, ANDROID_ASSETS_FONTS_DIR);
@@ -83,10 +79,10 @@ function withNanoIconsAndroid(config) {
     ]);
 }
 /**
- * Apply iOS and Android font linking. Built font list is read from config (set by build mod).
+ * Apply iOS and Android font linking.
  */
-function withNanoIconsFontLinking(config) {
-    config = withNanoIconsIos(config);
-    config = withNanoIconsAndroid(config);
+function withNanoIconsFontLinking(config, iconSets) {
+    config = withNanoIconsIos(config, iconSets);
+    config = withNanoIconsAndroid(config, iconSets);
     return config;
 }

package/lib/commonjs/scripts/cli.js

@@ -1,25 +1,35 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Bare React Native workflow: build icon fonts and link them into the native project.
  *
- * Run from your app root: npx react-native-nano-icons [--verbose]
+ * Run from your app root: npx react-native-nano-icons [--verbose] [--path <dir>]
  *
  * Reads .nanoicons.json (same shape as Expo plugin options) so Expo and bare apps
  * share one config format.
  *
  * Flags:
- *   --verbose   Show per-SVG processing details and pipeline timing
+ *   --verbose        Show per-SVG processing details and pipeline timing
+ *   --path <dir>     Directory containing .nanoicons.json (default: cwd)
  */
+const node_path_1 = __importDefault(require("node:path"));
 const index_js_1 = require("../cli/index.js");
 async function main() {
     const verbose = process.argv.includes('--verbose');
     const level = verbose ? 'verbose' : 'normal';
+    const pathIdx = process.argv.indexOf('--path');
+    const projectRoot = process.cwd();
+    const configRoot = pathIdx !== -1 && process.argv[pathIdx + 1]
+        ? node_path_1.default.resolve(projectRoot, process.argv[pathIdx + 1])
+        : projectRoot;
     const logger = await (0, index_js_1.createOraLogger)(level);
-    const config = (0, index_js_1.loadNanoIconsConfig)(process.cwd());
-    const built = await (0, index_js_1.buildAllFonts)(config.iconSets, process.cwd(), { logger });
-    await (0, index_js_1.linkBare)(process.cwd(), built, logger);
+    const config = (0, index_js_1.loadNanoIconsConfig)(configRoot);
+    const built = await (0, index_js_1.buildAllFonts)(config.iconSets, projectRoot, { logger });
+    await (0, index_js_1.linkBare)(projectRoot, built, logger);
 }
 main().catch((err) => {
     const message = err instanceof Error ? err.message : String(err);

package/lib/commonjs/src/core/font/compile.d.ts

@@ -1,5 +1,16 @@
-export declare function compileTtfFromGlyphSVGs(opts: {
-    glyphDir: string;
+export type FontGlyph = {
+    codepoint: number;
+    advanceWidth: number;
+    /** Path data already in font coordinates (Y-up, placement applied). */
+    d: string;
+};
+export declare function parseCompileTtfFromGlyphsError(err: unknown, codepointToIcon: Map<number, string>): void;
+/**
+ * Compile a TTF font from pre-transformed glyph data.
+ * Builds SVG font XML directly (no intermediate files), then converts via svg2ttf.
+ */
+export declare function compileTtfFromGlyphs(opts: {
+    glyphs: FontGlyph[];
     outTtfPath: string;
     fontName: string;
     upm: number;

package/lib/commonjs/src/core/font/compile.js

@@ -3,63 +3,66 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileTtfFromGlyphSVGs = compileTtfFromGlyphSVGs;
+exports.parseCompileTtfFromGlyphsError = parseCompileTtfFromGlyphsError;
+exports.compileTtfFromGlyphs = compileTtfFromGlyphs;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const node_events_1 = require("node:events");
 const metrics_js_1 = require("./metrics.js");
 const svg2ttf_1 = __importDefault(require("svg2ttf"));
-const parse_js_1 = require("../../utils/parse.js");
-async function writeGlyphStreamToFont(fontStream, svgPath, filename) {
-    const codepoint = (0, parse_js_1.parseCodepointFromFilename)(filename);
-    const name = node_path_1.default.basename(filename, '.svg');
-    return new Promise((resolve, reject) => {
-        const glyphStream = node_fs_1.default.createReadStream(svgPath);
-        glyphStream.metadata = {
-            name,
-            unicode: [String.fromCodePoint(codepoint)],
-        };
-        glyphStream.on('error', reject);
-        // Do not add fontStream.on("error", reject) here — one per glyph would exceed
-        // Node's default MaxListeners (10). Font stream errors are handled once below.
-        fontStream.write(glyphStream);
-        glyphStream.on('end', resolve);
+function escapeXml(s) {
+    return s.replace(/&/g, '&').replace(/"/g, '"');
+}
+/**
+ * Build an SVG font XML string from pre-transformed glyph data.
+ */
+function buildSvgFontXml(opts) {
+    const { fontName, glyphs, upm, ascent, descent } = opts;
+    const glyphLines = glyphs.map((g) => {
+        const hex = g.codepoint.toString(16);
+        const name = `u${hex.padStart(4, '0')}`;
+        return `<glyph glyph-name="${name}" unicode="&#x${hex};" horiz-adv-x="${g.advanceWidth}" d="${escapeXml(g.d)}"/>`;
     });
+    return `<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg">
+<defs>
+<font id="${escapeXml(fontName)}" horiz-adv-x="${upm}">
+<font-face font-family="${escapeXml(fontName)}" units-per-em="${upm}" ascent="${ascent}" descent="${-Math.abs(descent)}"/>
+<missing-glyph horiz-adv-x="0"/>
+${glyphLines.join('\n')}
+</font>
+</defs>
+</svg>`;
+}
+function parseCompileTtfFromGlyphsError(err, codepointToIcon) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const cpMatch = msg.match(/glyph\s+"u([0-9a-fA-F]+)"/);
+    if (cpMatch) {
+        const cp = parseInt(cpMatch[1], 16);
+        const iconName = codepointToIcon.get(cp);
+        const detail = iconName
+            ? `icon "${iconName}" (codepoint u${cpMatch[1]})`
+            : `codepoint u${cpMatch[1]}`;
+        throw new Error(`Font compilation failed for ${detail}: ${msg}`);
+    }
+    throw err;
 }
-async function compileTtfFromGlyphSVGs(opts) {
-    const { SVGIcons2SVGFontStream } = await import('svgicons2svgfont');
-    const { glyphDir, outTtfPath, fontName, upm, ascent, descent } = opts;
+/**
+ * Compile a TTF font from pre-transformed glyph data.
+ * Builds SVG font XML directly (no intermediate files), then converts via svg2ttf.
+ */
+async function compileTtfFromGlyphs(opts) {
+    const { glyphs, outTtfPath, fontName, upm, ascent, descent } = opts;
     const lineGap = opts.lineGap ?? 0;
-    const files = node_fs_1.default
-        .readdirSync(glyphDir)
-        .filter((f) => /^u[0-9a-fA-F]+\.svg$/.test(f))
-        .sort((a, b) => (0, parse_js_1.parseCodepointFromFilename)(a) - (0, parse_js_1.parseCodepointFromFilename)(b));
-    if (files.length === 0)
-        throw new Error(`No glyph SVGs found in: ${glyphDir}`);
-    const fontStream = new SVGIcons2SVGFontStream({
+    if (glyphs.length === 0)
+        throw new Error('No glyphs to compile');
+    const svgFontString = buildSvgFontXml({
         fontName,
-        fontHeight: upm,
-        normalize: false,
+        glyphs,
+        upm,
         ascent,
         descent,
     });
-    const svgFontChunks = [];
-    fontStream.on('data', (c) => svgFontChunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c)));
-    // Single error listener for the font stream; per-glyph errors are handled in writeGlyphStreamToFont.
-    let fontStreamReject;
-    const fontStreamErrorPromise = new Promise((_, rej) => {
-        fontStreamReject = rej;
-    });
-    fontStream.on('error', (err) => fontStreamReject(err));
-    for (const f of files) {
-        await Promise.race([
-            writeGlyphStreamToFont(fontStream, node_path_1.default.join(glyphDir, f), f),
-            fontStreamErrorPromise,
-        ]);
-    }
-    fontStream.end();
-    await (0, node_events_1.once)(fontStream, 'end');
-    const svgFontString = Buffer.concat(svgFontChunks).toString('utf8');
     const ttfRaw = (0, svg2ttf_1.default)(svgFontString);
     const rawBuf = Buffer.from(ttfRaw.buffer);
     const fixedBuf = (0, metrics_js_1.forceTtfMetrics)(rawBuf, upm, ascent, descent, lineGap);

package/lib/commonjs/src/core/pipeline/managers.js

@@ -56,14 +56,30 @@ class PyodideManager {
         const pathopsPy = await promises_1.default.readFile(pathopsPyPath, 'utf8');
         py.FS.writeFile('/pathops.py', pathopsPy);
         await py.loadPackage(['micropip', 'lxml'], { messageCallback: () => { } });
+        // Resolve local picosvg wheel path for offline-first installation.
+        const picosvgWhlDir = node_path_1.default.join(getPackageRoot(), 'src', 'core', 'shims');
+        const picosvgWhl = (await promises_1.default.readdir(picosvgWhlDir))
+            .find((f) => f.startsWith('picosvg-') && f.endsWith('.whl'));
+        const localWhlUrl = picosvgWhl
+            ? `file://${node_path_1.default.join(picosvgWhlDir, picosvgWhl)}`
+            : null;
+        py.globals.set('_picosvg_local_whl', localWhlUrl);
         await py.runPythonAsync(`
       import sys
       if "/" not in sys.path:
           sys.path.insert(0, "/")
-          
+
       import micropip
-      await micropip.install("picosvg", deps=False)
-          
+
+      _whl = _picosvg_local_whl
+      if _whl:
+          try:
+              await micropip.install(_whl, deps=False)
+          except Exception:
+              await micropip.install("picosvg", deps=False)
+      else:
+          await micropip.install("picosvg", deps=False)
+
       import pathops
       import picosvg
     `);

package/lib/commonjs/src/core/pipeline/run.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runPipeline = runPipeline;
-const node_fs_1 = __importDefault(require("node:fs"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const compile_js_1 = require("../font/compile.js");
@@ -12,6 +11,64 @@ const managers_js_1 = require("./managers.js");
 const config_js_1 = require("./config.js");
 const svg_dom_js_1 = require("../svg/svg_dom.js");
 const layers_js_1 = require("../svg/layers.js");
+const svg_pathops_js_1 = require("../svg/svg_pathops.js");
+/**
+ * Concatenate multiple SVG path `d` strings into a single compound path.
+ * This preserves the exact geometry of each path (no boolean operations)
+ * while combining them into one glyph. Under nonzero winding, this renders
+ * identically to drawing each path separately with the same color.
+ */
+function concatPathDs(ds) {
+    if (ds.length === 0)
+        return null;
+    if (ds.length === 1)
+        return ds[0];
+    return ds.join(' ');
+}
+/**
+ * Merge consecutive same-color paths into single compound paths via boolean UNION.
+ * Preserves z-order: only merges runs of adjacent paths with identical fill color.
+ */
+function mergeSameColorPaths(paths, logger) {
+    if (paths.length <= 1)
+        return paths;
+    const result = [];
+    let i = 0;
+    while (i < paths.length) {
+        const fill = paths[i].fill;
+        // Find consecutive run of same fill that are all mergeable.
+        // Paths converted from evenodd have compound hole structure and must not
+        // be merged — their CW hole contours would cancel CCW contours from
+        // adjacent paths, producing incorrect fill.
+        let j = i + 1;
+        if (!paths[i].noMerge) {
+            while (j < paths.length &&
+                paths[j].fill === fill &&
+                !paths[j].noMerge) {
+                j++;
+            }
+        }
+        if (j - i === 1) {
+            result.push(paths[i]);
+        }
+        else {
+            const group = paths.slice(i, j);
+            const merged = concatPathDs(group.map((p) => p.d));
+            if (merged) {
+                logger?.info(`    ⊕ Merged ${group.length} same-color paths (fill=${fill})`);
+                result.push({ d: merged, fill });
+            }
+            else {
+                result.push(...group);
+            }
+        }
+        i = j;
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Pipeline
+// ---------------------------------------------------------------------------
 /**
  * Run the font pipeline with given config and paths.
  * Uses the singleton Pyodide/PathKit instance (initialized on first call).
@@ -20,19 +77,21 @@ async function runPipeline(config, paths, options) {
     const startTime = Date.now();
     const logger = options?.logger;
     logger?.update(`Building "${config.fontFamily}"…`);
-    (0, config_js_1.ensureEmptyDir)(paths.tempDir);
     (0, config_js_1.ensureDir)(paths.outputDir);
     const files = (await promises_1.default.readdir(paths.inputDir)).filter((f) => f.toLowerCase().endsWith('.svg'));
     const glyphMap = {
-        meta: {
-            fontFamily: config.fontFamily,
-            upm: config.upm,
-            safeZone: config.safeZone,
-            startUnicode: config.startUnicode,
+        m: {
+            f: config.fontFamily,
+            u: config.upm,
+            z: config.safeZone,
+            s: config.startUnicode,
         },
-        icons: {},
+        i: {},
     };
     let currentUnicode = config.startUnicode;
+    const codepointToIcon = new Map();
+    const allGlyphs = [];
+    const PathKit = await managers_js_1.PathKitManager.getInstance();
     for (const file of files) {
         const iconName = node_path_1.default.parse(file).name;
         const filePath = node_path_1.default.join(paths.inputDir, file);
@@ -44,55 +103,85 @@ async function runPipeline(config, paths, options) {
             continue;
         }
         const preprocessed = (0, svg_dom_js_1.preprocessSvg)(rawContent);
+        // Preserve original evenodd `d` strings BEFORE picosvg processes them.
+        // Picosvg's simplify (via our PathKit shim) can drop contours from
+        // multi-subpath evenodd paths — we restore the originals after.
+        const originalEvenoddDs = (0, svg_dom_js_1.extractOriginalEvenoddDs)(preprocessed);
         const flattenedSvg = await (0, managers_js_1.picoFromFile)(filePath, preprocessed);
-        const parsed = (0, svg_dom_js_1.parseFlattenedSvg)(flattenedSvg);
+        const parsed = (0, svg_dom_js_1.parseFlattenedSvg)(flattenedSvg, {
+            onSanitize: (original) => {
+                logger?.info(`  ⚠ Sanitized path in "${file}": path was missing initial moveto (prepended M from endpoint)`);
+                logger?.info(`    Original: ${original.slice(0, 80)}…`);
+            },
+        });
+        // Restore original evenodd path data (undamaged by picosvg's simplify),
+        // then convert to nonzero winding with our containment-based algorithm.
+        // Mark as noMerge — compound paths with holes must stay separate so their
+        // CW hole contours don't cancel adjacent paths' CCW contours.
+        if (originalEvenoddDs.length > 0) {
+            (0, svg_dom_js_1.restoreOriginalEvenoddDs)(parsed.paths, originalEvenoddDs);
+        }
+        for (const p of parsed.paths) {
+            if (p.fillRule === 'evenodd') {
+                logger?.info(`  ↻ Converting evenodd path to nonzero winding in "${file}"`);
+                p.d = (0, svg_pathops_js_1.convertEvenoddToWinding)(PathKit, p.d);
+                delete p.fillRule;
+                p.noMerge = true;
+            }
+        }
+        // Merge consecutive same-color paths into single compound glyphs
+        const mergedPaths = mergeSameColorPaths(parsed.paths, logger);
         const { vx, vy, scale, xOff, yOff, adv } = (0, layers_js_1.computePlacement)({
             upm: config.upm,
             safeZone: config.safeZone,
             viewBox: parsed.viewBox,
         });
-        const entry = { adv, layers: [] };
-        for (const p of parsed.paths) {
+        const layers = [];
+        for (const p of mergedPaths) {
             if ((0, svg_dom_js_1.shouldSkipPath)(p.d, p.fill))
                 continue;
             const cp = currentUnicode++;
-            await (0, layers_js_1.writeLayerSvg)({
-                tempDir: paths.tempDir,
-                upm: config.upm,
-                adv,
+            codepointToIcon.set(cp, iconName);
+            const fontD = (0, layers_js_1.transformPathForFont)(PathKit, p.d, {
                 vx,
                 vy,
                 scale,
                 xOff,
                 yOff,
-                d: p.d,
+                upm: config.upm,
+            });
+            allGlyphs.push({
                 codepoint: cp,
+                advanceWidth: adv,
+                d: fontD,
             });
-            entry.layers.push({ codepoint: cp, color: p.fill || 'black' });
+            layers.push([cp, p.fill || 'black']);
         }
-        if (entry.layers.length > 0) {
-            glyphMap.icons[iconName] = entry;
+        if (layers.length > 0) {
+            glyphMap.i[iconName] = [adv, layers];
         }
     }
     const glyphmapPath = node_path_1.default.join(paths.outputDir, `${config.fontFamily}.glyphmap.json`);
     if (options?.inputHash) {
-        glyphMap.meta.hash = options.inputHash;
+        glyphMap.m.h = options.inputHash;
     }
-    await promises_1.default.writeFile(glyphmapPath, JSON.stringify(glyphMap, null, 2), 'utf8');
+    await promises_1.default.writeFile(glyphmapPath, JSON.stringify(glyphMap), 'utf8');
     logger?.info(`Compiling TTF…`);
     const ttfPath = node_path_1.default.join(paths.outputDir, `${config.fontFamily}.ttf`);
-    await (0, compile_js_1.compileTtfFromGlyphSVGs)({
-        glyphDir: paths.tempDir,
-        outTtfPath: ttfPath,
-        fontName: config.fontFamily,
-        upm: config.upm,
-        ascent: config.upm,
-        descent: 0,
-    });
-    if (node_fs_1.default.existsSync(paths.tempDir)) {
-        node_fs_1.default.rmSync(paths.tempDir, { recursive: true, force: true });
+    try {
+        await (0, compile_js_1.compileTtfFromGlyphs)({
+            glyphs: allGlyphs,
+            outTtfPath: ttfPath,
+            fontName: config.fontFamily,
+            upm: config.upm,
+            ascent: config.upm,
+            descent: 0,
+        });
+    }
+    catch (err) {
+        (0, compile_js_1.parseCompileTtfFromGlyphsError)(err, codepointToIcon);
     }
-    const iconCount = Object.keys(glyphMap.icons).length;
+    const iconCount = Object.keys(glyphMap.i).length;
     const elapsed = Date.now() - startTime;
     logger?.succeed(`Built ${config.fontFamily}.ttf [${iconCount} icon${iconCount === 1 ? '' : 's'} in ${elapsed}ms]`);
     return { ttfPath, glyphmapPath };

package/lib/commonjs/src/core/svg/layers.d.ts

@@ -1,3 +1,4 @@
+import type { PathKitModule } from '../types.js';
 export declare function computePlacement(opts: {
     upm: number;
     safeZone: number;
@@ -22,3 +23,18 @@ export declare function writeLayerSvg(opts: {
     d: string;
     codepoint: number;
 }): Promise<void>;
+/**
+ * Transform an SVG path `d` string from source SVG coordinates into font
+ * glyph coordinates (Y-up, with placement scaling and centering applied).
+ *
+ * Combines placement transform (translate + scale + translate) with the
+ * SVG→font Y-axis flip into a single affine transform applied via PathKit.
+ */
+export declare function transformPathForFont(PathKit: PathKitModule, d: string, opts: {
+    vx: number;
+    vy: number;
+    scale: number;
+    xOff: number;
+    yOff: number;
+    upm: number;
+}): string;