react-native-nano-icons 0.0.0 → 0.1.0

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

@@ -0,0 +1,5 @@
+import type { ConfigPlugin } from '@expo/config-plugins';
+import type { NanoIconsPluginOptions } from './types.js';
+declare const withNanoIcons: ConfigPlugin<NanoIconsPluginOptions>;
+export default withNanoIcons;
+export type { NanoIconsPluginOptions, IconSetConfig, BuiltFont, } from './types.js';

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

@@ -0,0 +1,43 @@
+"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);
+    return config;
+};
+exports.default = withNanoIcons;

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

@@ -0,0 +1,31 @@
+/**
+ * Config for one icon set: input SVGs → one TTF + glyphmap.
+ */
+export interface IconSetConfig {
+    /** Path to folder of SVG files (relative to project root). */
+    inputDir: string;
+    /** Font family name (used for TTF and glyphmap filenames). */
+    fontFamily: string;
+    /** Path where .ttf and .glyphmap.json will be saved. Defaults to a sibling nanoicons folder relative to inputDir. */
+    outputDir?: string;
+    /** Units per em (default 1024). */
+    upm?: number;
+    /** Safe zone inside UPM for glyphs (default 1020). */
+    safeZone?: number;
+    /** First Unicode codepoint for glyphs (default 0xe900). Hex string or number. */
+    startUnicode?: number | string;
+}
+/**
+ * plugins: [ [ "react-native-nano-icons", { iconSets: [...] } ] ]
+ */
+export interface NanoIconsPluginOptions {
+    iconSets: IconSetConfig[];
+}
+/**
+ * Result of building one icon set.
+ */
+export interface BuiltFont {
+    fontFamily: string;
+    ttfPath: string;
+    glyphmapPath: string;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,14 @@
+import { withXcodeProject, withDangerousMod } from '@expo/config-plugins';
+/**
+ * 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>;
+/**
+ * Copy TTFs to Android assets/fonts. Reads paths from config._nanoIconsBuilt.
+ */
+export declare function withNanoIconsAndroid(config: Parameters<typeof withDangerousMod>[0]): ReturnType<typeof withDangerousMod>;
+/**
+ * Apply iOS and Android font linking. Built font list is read from config (set by build mod).
+ */
+export declare function withNanoIconsFontLinking(config: Parameters<typeof withNanoIconsIos>[0]): ReturnType<typeof withNanoIconsAndroid>;

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

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withNanoIconsIos = withNanoIconsIos;
+exports.withNanoIconsAndroid = withNanoIconsAndroid;
+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 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) {
+    config = (0, config_plugins_1.withXcodeProject)(config, async (config) => {
+        const built = getBuiltFonts(config);
+        if (!built?.length)
+            return config;
+        const ttfPaths = built.map((b) => b.ttfPath);
+        const project = config.modResults;
+        const platformProjectRoot = config.modRequest.platformProjectRoot;
+        config_plugins_1.IOSConfig.XcodeUtils.ensureGroupRecursively(project, 'Resources');
+        for (const fontPath of ttfPaths) {
+            const relativePath = path_1.default.relative(platformProjectRoot, fontPath);
+            config_plugins_1.IOSConfig.XcodeUtils.addResourceFileToGroup({
+                filepath: relativePath,
+                groupName: 'Resources',
+                project,
+                isBuildFile: true,
+                verbose: true,
+            });
+        }
+        return config;
+    });
+    config = (0, config_plugins_1.withInfoPlist)(config, async (config) => {
+        const built = getBuiltFonts(config);
+        if (!built?.length)
+            return config;
+        const ttfPaths = built.map((b) => b.ttfPath);
+        const existingFonts = getUIAppFonts(config.modResults);
+        const fontList = ttfPaths.map((f) => path_1.default.basename(f));
+        const allFonts = [...existingFonts, ...fontList];
+        config.modResults.UIAppFonts = Array.from(new Set(allFonts));
+        return config;
+    });
+    return config;
+}
+function getUIAppFonts(infoPlist) {
+    const fonts = infoPlist['UIAppFonts'];
+    if (fonts != null &&
+        Array.isArray(fonts) &&
+        fonts.every((font) => typeof font === 'string')) {
+        return fonts;
+    }
+    return [];
+}
+/**
+ * Copy TTFs to Android assets/fonts. Reads paths from config._nanoIconsBuilt.
+ */
+function withNanoIconsAndroid(config) {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        'android',
+        async (config) => {
+            const built = getBuiltFonts(config);
+            if (!built?.length)
+                return config;
+            const fontsDir = path_1.default.join(config.modRequest.platformProjectRoot, ANDROID_ASSETS_FONTS_DIR);
+            await promises_1.default.mkdir(fontsDir, { recursive: true });
+            for (const b of built) {
+                const filename = path_1.default.basename(b.ttfPath);
+                const dest = path_1.default.join(fontsDir, filename);
+                await promises_1.default.copyFile(b.ttfPath, dest);
+            }
+            return config;
+        },
+    ]);
+}
+/**
+ * Apply iOS and Android font linking. Built font list is read from config (set by build mod).
+ */
+function withNanoIconsFontLinking(config) {
+    config = withNanoIconsIos(config);
+    config = withNanoIconsAndroid(config);
+    return config;
+}

package/lib/commonjs/scripts/cli.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+"use strict";
+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]
+ *
+ * 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
+ */
+const index_js_1 = require("../cli/index.js");
+async function main() {
+    const verbose = process.argv.includes('--verbose');
+    const level = verbose ? 'verbose' : 'normal';
+    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);
+}
+main().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(message);
+    process.exit(1);
+});

package/lib/commonjs/src/const/colors.d.ts

@@ -0,0 +1 @@
+export declare const CSS_NAMED_COLORS: Record<string, [number, number, number]>;

package/lib/commonjs/src/const/colors.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSS_NAMED_COLORS = void 0;
+exports.CSS_NAMED_COLORS = {
+    aliceblue: [240, 248, 255],
+    antiquewhite: [250, 235, 215],
+    aqua: [0, 255, 255],
+    aquamarine: [127, 255, 212],
+    azure: [240, 255, 255],
+    beige: [245, 245, 220],
+    bisque: [255, 228, 196],
+    black: [0, 0, 0],
+    blanchedalmond: [255, 235, 205],
+    blue: [0, 0, 255],
+    blueviolet: [138, 43, 226],
+    brown: [165, 42, 42],
+    burlywood: [222, 184, 135],
+    cadetblue: [95, 158, 160],
+    chartreuse: [127, 255, 0],
+    chocolate: [210, 105, 30],
+    coral: [255, 127, 80],
+    cornflowerblue: [100, 149, 237],
+    cornsilk: [255, 248, 220],
+    crimson: [220, 20, 60],
+    cyan: [0, 255, 255],
+    darkblue: [0, 0, 139],
+    darkcyan: [0, 139, 139],
+    darkgoldenrod: [184, 134, 11],
+    darkgray: [169, 169, 169],
+    darkgreen: [0, 100, 0],
+    darkgrey: [169, 169, 169],
+    darkkhaki: [189, 183, 107],
+    darkmagenta: [139, 0, 139],
+    darkolivegreen: [85, 107, 47],
+    darkorange: [255, 140, 0],
+    darkorchid: [153, 50, 204],
+    darkred: [139, 0, 0],
+    darksalmon: [233, 150, 122],
+    darkseagreen: [143, 188, 143],
+    darkslateblue: [72, 61, 139],
+    darkslategray: [47, 79, 79],
+    darkslategrey: [47, 79, 79],
+    darkturquoise: [0, 206, 209],
+    darkviolet: [148, 0, 211],
+    deeppink: [255, 20, 147],
+    deepskyblue: [0, 191, 255],
+    dimgray: [105, 105, 105],
+    dimgrey: [105, 105, 105],
+    dodgerblue: [30, 144, 255],
+    firebrick: [178, 34, 34],
+    floralwhite: [255, 250, 240],
+    forestgreen: [34, 139, 34],
+    fuchsia: [255, 0, 255],
+    gainsboro: [220, 220, 220],
+    ghostwhite: [248, 248, 255],
+    gold: [255, 215, 0],
+    goldenrod: [218, 165, 32],
+    gray: [128, 128, 128],
+    green: [0, 128, 0],
+    greenyellow: [173, 255, 47],
+    grey: [128, 128, 128],
+    honeydew: [240, 255, 240],
+    hotpink: [255, 105, 180],
+    indianred: [205, 92, 92],
+    indigo: [75, 0, 130],
+    ivory: [255, 255, 240],
+    khaki: [240, 230, 140],
+    lavender: [230, 230, 250],
+    lavenderblush: [255, 240, 245],
+    lawngreen: [124, 252, 0],
+    lemonchiffon: [255, 250, 205],
+    lightblue: [173, 216, 230],
+    lightcoral: [240, 128, 128],
+    lightcyan: [224, 255, 255],
+    lightgoldenrodyellow: [250, 250, 210],
+    lightgray: [211, 211, 211],
+    lightgreen: [144, 238, 144],
+    lightgrey: [211, 211, 211],
+    lightpink: [255, 182, 193],
+    lightsalmon: [255, 160, 122],
+    lightseagreen: [32, 178, 170],
+    lightskyblue: [135, 206, 250],
+    lightslategray: [119, 136, 153],
+    lightslategrey: [119, 136, 153],
+    lightsteelblue: [176, 196, 222],
+    lightyellow: [255, 255, 224],
+    lime: [0, 255, 0],
+    limegreen: [50, 205, 50],
+    linen: [250, 240, 230],
+    magenta: [255, 0, 255],
+    maroon: [128, 0, 0],
+    mediumaquamarine: [102, 205, 170],
+    mediumblue: [0, 0, 205],
+    mediumorchid: [186, 85, 211],
+    mediumpurple: [147, 112, 219],
+    mediumseagreen: [60, 179, 113],
+    mediumslateblue: [123, 104, 238],
+    mediumspringgreen: [0, 250, 154],
+    mediumturquoise: [72, 209, 204],
+    mediumvioletred: [199, 21, 133],
+    midnightblue: [25, 25, 112],
+    mintcream: [245, 255, 250],
+    mistyrose: [255, 228, 225],
+    moccasin: [255, 228, 181],
+    navajowhite: [255, 222, 173],
+    navy: [0, 0, 128],
+    oldlace: [253, 245, 230],
+    olive: [128, 128, 0],
+    olivedrab: [107, 142, 35],
+    orange: [255, 165, 0],
+    orangered: [255, 69, 0],
+    orchid: [218, 112, 214],
+    palegoldenrod: [238, 232, 170],
+    palegreen: [152, 251, 152],
+    paleturquoise: [175, 238, 238],
+    palevioletred: [219, 112, 147],
+    papayawhip: [255, 239, 213],
+    peachpuff: [255, 218, 185],
+    peru: [205, 133, 63],
+    pink: [255, 192, 203],
+    plum: [221, 160, 221],
+    powderblue: [176, 224, 230],
+    purple: [128, 0, 128],
+    rebeccapurple: [102, 51, 153],
+    red: [255, 0, 0],
+    rosybrown: [188, 143, 143],
+    royalblue: [65, 105, 225],
+    saddlebrown: [139, 69, 19],
+    salmon: [250, 128, 114],
+    sandybrown: [244, 164, 96],
+    seagreen: [46, 139, 87],
+    seashell: [255, 245, 238],
+    sienna: [160, 82, 45],
+    silver: [192, 192, 192],
+    skyblue: [135, 206, 235],
+    slateblue: [106, 90, 205],
+    slategray: [112, 128, 144],
+    slategrey: [112, 128, 144],
+    snow: [255, 250, 250],
+    springgreen: [0, 255, 127],
+    steelblue: [70, 130, 180],
+    tan: [210, 180, 140],
+    teal: [0, 128, 128],
+    thistle: [216, 191, 216],
+    tomato: [255, 99, 71],
+    turquoise: [64, 224, 208],
+    violet: [238, 130, 238],
+    wheat: [245, 222, 179],
+    white: [255, 255, 255],
+    whitesmoke: [245, 245, 245],
+    yellow: [255, 255, 0],
+    yellowgreen: [154, 205, 50],
+};

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

@@ -0,0 +1,9 @@
+export declare function compileTtfFromGlyphSVGs(opts: {
+    glyphDir: string;
+    outTtfPath: string;
+    fontName: string;
+    upm: number;
+    ascent: number;
+    descent: number;
+    lineGap?: number;
+}): Promise<void>;

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

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTtfFromGlyphSVGs = compileTtfFromGlyphSVGs;
+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);
+    });
+}
+async function compileTtfFromGlyphSVGs(opts) {
+    const { SVGIcons2SVGFontStream } = await import('svgicons2svgfont');
+    const { glyphDir, 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({
+        fontName,
+        fontHeight: upm,
+        normalize: false,
+        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);
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(outTtfPath), { recursive: true });
+    node_fs_1.default.writeFileSync(outTtfPath, fixedBuf);
+}

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

@@ -0,0 +1 @@
+export declare function forceTtfMetrics(ttfBuffer: Buffer, upm: number, ascent: number, descent: number, lineGap: number): Buffer;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forceTtfMetrics = forceTtfMetrics;
+const fonteditor_core_1 = require("fonteditor-core");
+function forceTtfMetrics(ttfBuffer, upm, ascent, descent, lineGap) {
+    const font = fonteditor_core_1.Font.create(ttfBuffer, {
+        type: 'ttf',
+        hinting: false,
+        compound2simple: false,
+        combinePath: false,
+    });
+    const data = font.get();
+    data.head.unitsPerEm = upm;
+    data.hhea.ascent = ascent;
+    data.hhea.descent = -Math.abs(descent);
+    data.hhea.lineGap = lineGap;
+    data['OS/2'].usWinAscent = ascent;
+    data['OS/2'].usWinDescent = Math.abs(descent);
+    data['OS/2'].sTypoAscender = ascent;
+    data['OS/2'].sTypoDescender = -Math.abs(descent);
+    data['OS/2'].sTypoLineGap = lineGap;
+    // Set USE_TYPO_METRICS flag (bit 7) in fsSelection.
+    // This tells renderers to use sTypoAscender/sTypoDescender/sTypoLineGap for
+    // line height calculations instead of the Win metrics (usWinAscent/usWinDescent).
+    // Without this flag, Windows and some Android renderers ignore the Typo values
+    // set above and fall back to Win metrics, causing icons to appear clipped or
+    // misaligned vertically. The bitwise OR preserves all other existing style flags
+    // (italic, bold, etc.) while ensuring this bit is always on.
+    data['OS/2'].fsSelection = (data['OS/2'].fsSelection || 0) | (1 << 7);
+    font.set(data);
+    const out = font.write({ type: 'ttf', hinting: false });
+    return Buffer.from(out);
+}

package/lib/commonjs/src/core/pipeline/config.d.ts

@@ -0,0 +1,14 @@
+export type PipelineConfig = {
+    fontFamily: string;
+    upm: number;
+    safeZone: number;
+    startUnicode: number;
+};
+export type PipelinePaths = {
+    inputDir: string;
+    outputDir: string;
+    tempDir: string;
+};
+export declare function ensureEmptyDir(dir: string): void;
+/** Create directory if it does not exist; do not remove existing contents (for shared output dirs). */
+export declare function ensureDir(dir: string): void;

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

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureEmptyDir = ensureEmptyDir;
+exports.ensureDir = ensureDir;
+const node_fs_1 = __importDefault(require("node:fs"));
+function ensureEmptyDir(dir) {
+    if (node_fs_1.default.existsSync(dir))
+        node_fs_1.default.rmSync(dir, { recursive: true, force: true });
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+}
+/** Create directory if it does not exist; do not remove existing contents (for shared output dirs). */
+function ensureDir(dir) {
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+}

package/lib/commonjs/src/core/pipeline/index.d.ts

@@ -0,0 +1,3 @@
+export { runPipeline, type PipelineResult } from './run.js';
+export type { PipelineConfig, PipelinePaths } from './config.js';
+export { ensureEmptyDir } from './config.js';

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureEmptyDir = exports.runPipeline = void 0;
+var run_js_1 = require("./run.js");
+Object.defineProperty(exports, "runPipeline", { enumerable: true, get: function () { return run_js_1.runPipeline; } });
+var config_js_1 = require("./config.js");
+Object.defineProperty(exports, "ensureEmptyDir", { enumerable: true, get: function () { return config_js_1.ensureEmptyDir; } });

package/lib/commonjs/src/core/pipeline/managers.d.ts

@@ -0,0 +1,11 @@
+import type { PathKitModule, PyodideModule } from '../types.js';
+export declare class PathKitManager {
+    private static instance;
+    static getInstance(): Promise<PathKitModule>;
+}
+export declare class PyodideManager {
+    private static instance;
+    static getInstance(): Promise<PyodideModule>;
+    static picoFromFile(hostFilePath: string, content?: string): Promise<string>;
+}
+export declare function picoFromFile(hostFilePath: string, content?: string): Promise<string>;

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

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PyodideManager = exports.PathKitManager = void 0;
+exports.picoFromFile = picoFromFile;
+const pyodide_1 = require("pyodide");
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const svg_pathops_js_1 = require("../svg/svg_pathops.js");
+/** Package root (where package.json lives). */
+function getPackageRoot() {
+    // Compiled to lib/commonjs/src/core/pipeline/ — 5 dirs up is package root.
+    // Running from source (Jest/ts-node) in src/core/pipeline/ — 3 dirs up is package root.
+    return __dirname.includes(`${node_path_1.default.sep}lib${node_path_1.default.sep}`)
+        ? node_path_1.default.resolve(__dirname, '../../../../..')
+        : node_path_1.default.resolve(__dirname, '../../..');
+}
+class PathKitManager {
+    static instance = null;
+    static async getInstance() {
+        if (this.instance)
+            return this.instance;
+        const PathKitInit = require('pathkit-wasm/bin/pathkit.js');
+        const pathkitJsPath = require.resolve('pathkit-wasm/bin/pathkit.js');
+        const pathkitBinDir = node_path_1.default.dirname(pathkitJsPath);
+        const pathkitWasmPath = node_path_1.default.join(pathkitBinDir, 'pathkit.wasm');
+        const wasmBinary = await promises_1.default.readFile(pathkitWasmPath);
+        const pkInit = PathKitInit({
+            wasmBinary,
+            locateFile: (file) => node_path_1.default.join(pathkitBinDir, file),
+        });
+        const PathKit = await (typeof pkInit?.ready === 'function'
+            ? pkInit.ready()
+            : pkInit);
+        this.instance = PathKit;
+        return PathKit;
+    }
+}
+exports.PathKitManager = PathKitManager;
+class PyodideManager {
+    static instance = null;
+    static async getInstance() {
+        if (this.instance)
+            return this.instance;
+        const pyodideAsmPath = require.resolve('pyodide/pyodide.asm.js');
+        const pyodideDir = node_path_1.default.dirname(pyodideAsmPath) + node_path_1.default.sep;
+        const py = (await (0, pyodide_1.loadPyodide)({
+            indexURL: pyodideDir,
+        }));
+        py.mountNodeFS('/app', process.cwd());
+        const PathKit = await PathKitManager.getInstance();
+        py.registerJsModule('_pathops_js', (0, svg_pathops_js_1.buildPathopsBackend)(PathKit));
+        const pathopsPyPath = node_path_1.default.join(getPackageRoot(), 'src', 'core', 'shims', 'pathops.py');
+        const pathopsPy = await promises_1.default.readFile(pathopsPyPath, 'utf8');
+        py.FS.writeFile('/pathops.py', pathopsPy);
+        await py.loadPackage(['micropip', 'lxml'], { messageCallback: () => { } });
+        await py.runPythonAsync(`
+      import sys
+      if "/" not in sys.path:
+          sys.path.insert(0, "/")
+          
+      import micropip
+      await micropip.install("picosvg", deps=False)
+          
+      import pathops
+      import picosvg
+    `);
+        this.instance = py;
+        return py;
+    }
+    static async picoFromFile(hostFilePath, content) {
+        const py = await this.getInstance();
+        const svgContent = content ?? (await promises_1.default.readFile(hostFilePath, 'utf-8'));
+        py.globals.set('_svg_content', svgContent);
+        const out = py.runPython(`
+      from picosvg.svg import SVG
+      svg = SVG.fromstring(_svg_content)
+      pico = svg.topicosvg()
+      pico.tostring(pretty_print=True)
+    `);
+        return out;
+    }
+}
+exports.PyodideManager = PyodideManager;
+async function picoFromFile(hostFilePath, content) {
+    return PyodideManager.picoFromFile(hostFilePath, content);
+}

package/lib/commonjs/src/core/pipeline/run.d.ts

@@ -0,0 +1,14 @@
+import { type PipelineConfig, type PipelinePaths } from './config.js';
+import type { NanoLogger } from '../types.js';
+export type PipelineResult = {
+    ttfPath: string;
+    glyphmapPath: string;
+};
+/**
+ * Run the font pipeline with given config and paths.
+ * Uses the singleton Pyodide/PathKit instance (initialized on first call).
+ */
+export declare function runPipeline(config: PipelineConfig, paths: PipelinePaths, options?: {
+    logger?: NanoLogger;
+    inputHash?: string;
+}): Promise<PipelineResult>;