react-native-nano-icons 0.1.1 → 0.1.3

package/plugin/src/index.ts

@@ -1,31 +1,6 @@
-import type {
-  ConfigPlugin,
-  ExportedConfigWithProps,
-} from '@expo/config-plugins';
-import { withDangerousMod } from '@expo/config-plugins';
-import { buildAllFonts } from './buildFonts.js';
+import type { ConfigPlugin } from '@expo/config-plugins';
 import { withNanoIconsFontLinking } from './withNanoIconsFontLinking.js';
-import type {
-  NanoIconsPluginOptions,
-  IconSetConfig,
-  BuiltFont,
-} from './types.js';
-
-const BUILT_FONTS_KEY = '_nanoIconsBuilt';
-
-// Single Pyodide/PathKit run for the whole prebuild; reused across ios/android mods.
-let _builtFontsCache: BuiltFont[] | null = null;
-
-function getOrBuildFonts(
-  projectRoot: string,
-  iconSets: IconSetConfig[]
-): Promise<BuiltFont[]> {
-  if (_builtFontsCache) return Promise.resolve(_builtFontsCache);
-  return buildAllFonts(iconSets, projectRoot).then((built: BuiltFont[]) => {
-    _builtFontsCache = built;
-    return built;
-  });
-}
+import type { NanoIconsPluginOptions } from './types.js';
 
 const withNanoIcons: ConfigPlugin<NanoIconsPluginOptions> = (
   config,
@@ -33,29 +8,7 @@ const withNanoIcons: ConfigPlugin<NanoIconsPluginOptions> = (
 ) => {
   if (!options?.iconSets?.length) return config;
 
-  // Build fonts (once per process, cached) and attach to config for linking mods.
-  config = withDangerousMod(config, [
-    'ios',
-    async (config: ExportedConfigWithProps<unknown>) => {
-      const projectRoot = config.modRequest.projectRoot;
-      const built = await getOrBuildFonts(projectRoot, options.iconSets);
-      (config as unknown as Record<string, unknown>)[BUILT_FONTS_KEY] = built;
-      return config;
-    },
-  ]);
-
-  config = withDangerousMod(config, [
-    'android',
-    async (config: ExportedConfigWithProps<unknown>) => {
-      const projectRoot = config.modRequest.projectRoot;
-      const built = await getOrBuildFonts(projectRoot, options.iconSets);
-      (config as unknown as Record<string, unknown>)[BUILT_FONTS_KEY] = built;
-      return config;
-    },
-  ]);
-
-  // Link built TTFs into native projects (reads _nanoIconsBuilt from config).
-  config = withNanoIconsFontLinking(config);
+  config = withNanoIconsFontLinking(config, options.iconSets);
 
   return config;
 };

package/plugin/src/withNanoIconsFontLinking.ts

@@ -4,31 +4,25 @@ import {
   withXcodeProject,
   withDangerousMod,
 } from '@expo/config-plugins';
+import type { InfoPlist } from '@expo/config-plugins';
 import fs from 'fs/promises';
 import path from 'path';
-import type { BuiltFont } from './types.js';
-type InfoPlist = Record<string, unknown>;
+import { getOrBuildFonts } from './buildFonts.js';
+import type { IconSetConfig } from './types.js';
 
 const ANDROID_ASSETS_FONTS_DIR = 'app/src/main/assets/fonts';
 
-const BUILT_FONTS_KEY = '_nanoIconsBuilt' as const;
-
-function getBuiltFonts(config: {
-  [key: string]: unknown;
-}): BuiltFont[] | undefined {
-  return config[BUILT_FONTS_KEY] as BuiltFont[] | undefined;
-}
-
 /**
  * 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 function withNanoIconsIos(
-  config: Parameters<typeof withXcodeProject>[0]
+  config: Parameters<typeof withXcodeProject>[0],
+  iconSets: IconSetConfig[]
 ): ReturnType<typeof withXcodeProject> {
   config = withXcodeProject(config, async (config) => {
-    const built = getBuiltFonts(
-      config as unknown as { [key: string]: unknown }
+    const built = await getOrBuildFonts(
+      config.modRequest.projectRoot,
+      iconSets
     );
     if (!built?.length) return config;
     const ttfPaths = built.map((b) => b.ttfPath);
@@ -51,8 +45,9 @@ export function withNanoIconsIos(
   config = withInfoPlist(
     config as Parameters<typeof withInfoPlist>[0],
     async (config) => {
-      const built = getBuiltFonts(
-        config as unknown as { [key: string]: unknown }
+      const built = await getOrBuildFonts(
+        config.modRequest.projectRoot,
+        iconSets
       );
       if (!built?.length) return config;
       const ttfPaths = built.map((b) => b.ttfPath);
@@ -80,16 +75,18 @@ function getUIAppFonts(infoPlist: InfoPlist): string[] {
 }
 
 /**
- * Copy TTFs to Android assets/fonts. Reads paths from config._nanoIconsBuilt.
+ * Copy TTFs to Android assets/fonts.
  */
 export function withNanoIconsAndroid(
-  config: Parameters<typeof withDangerousMod>[0]
+  config: Parameters<typeof withDangerousMod>[0],
+  iconSets: IconSetConfig[]
 ): ReturnType<typeof withDangerousMod> {
   return withDangerousMod(config, [
     'android',
     async (config) => {
-      const built = getBuiltFonts(
-        config as unknown as { [key: string]: unknown }
+      const built = await getOrBuildFonts(
+        config.modRequest.projectRoot,
+        iconSets
       );
       if (!built?.length) return config;
       const fontsDir = path.join(
@@ -108,12 +105,13 @@ export function withNanoIconsAndroid(
 }
 
 /**
- * Apply iOS and Android font linking. Built font list is read from config (set by build mod).
+ * Apply iOS and Android font linking.
  */
 export function withNanoIconsFontLinking(
-  config: Parameters<typeof withNanoIconsIos>[0]
+  config: Parameters<typeof withNanoIconsIos>[0],
+  iconSets: IconSetConfig[]
 ): ReturnType<typeof withNanoIconsAndroid> {
-  config = withNanoIconsIos(config);
-  config = withNanoIconsAndroid(config);
+  config = withNanoIconsIos(config, iconSets);
+  config = withNanoIconsAndroid(config, iconSets);
   return config;
 }

package/react-native-nano-icons.podspec

@@ -0,0 +1,18 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-nano-icons"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.author       = package["author"]
+  s.source       = { :git => package["repository"], :tag => "#{s.version}" }
+  s.platforms    = { :ios => "15.1" }
+  s.source_files = "ios/**/*.{h,m,mm,cpp}"
+  s.requires_arc = true
+
+  install_modules_dependencies(s)
+end

package/scripts/cli.ts

@@ -2,14 +2,16 @@
 /**
  * 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)
  */
+import path from 'node:path';
 import {
   createOraLogger,
   loadNanoIconsConfig,
@@ -21,10 +23,17 @@ async function main(): Promise<void> {
   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]
+      ? path.resolve(projectRoot, process.argv[pathIdx + 1]!)
+      : projectRoot;
+
   const logger = await createOraLogger(level);
-  const config = loadNanoIconsConfig(process.cwd());
-  const built = await buildAllFonts(config.iconSets, process.cwd(), { logger });
-  await linkBare(process.cwd(), built, logger);
+  const config = loadNanoIconsConfig(configRoot);
+  const built = await buildAllFonts(config.iconSets, projectRoot, { logger });
+  await linkBare(projectRoot, built, logger);
 }
 
 main().catch((err: unknown) => {

package/src/core/font/compile.ts

@@ -1,38 +1,74 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { once } from 'node:events';
-import { type Transform } from 'node:stream';
 
 import { forceTtfMetrics } from './metrics.js';
 import svg2ttf from 'svg2ttf';
-import { parseCodepointFromFilename } from '../../utils/parse.js';
 
-async function writeGlyphStreamToFont(
-  fontStream: Transform,
-  svgPath: string,
-  filename: string
-): Promise<void> {
-  const codepoint = parseCodepointFromFilename(filename);
-  const name = path.basename(filename, '.svg');
+export type FontGlyph = {
+  codepoint: number;
+  advanceWidth: number;
+  /** Path data already in font coordinates (Y-up, placement applied). */
+  d: string;
+};
 
-  return new Promise((resolve, reject) => {
-    const glyphStream = fs.createReadStream(svgPath);
+function escapeXml(s: string): string {
+  return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+}
 
-    (glyphStream as any).metadata = {
-      name,
-      unicode: [String.fromCodePoint(codepoint)],
-    };
+/**
+ * Build an SVG font XML string from pre-transformed glyph data.
+ */
+function buildSvgFontXml(opts: {
+  fontName: string;
+  glyphs: FontGlyph[];
+  upm: number;
+  ascent: number;
+  descent: number;
+}): string {
+  const { fontName, glyphs, upm, ascent, descent } = opts;
 
-    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);
+  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>`;
+}
+
+export function parseCompileTtfFromGlyphsError(
+  err: unknown,
+  codepointToIcon: Map<number, string>
+) {
+  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;
 }
 
-export async function compileTtfFromGlyphSVGs(opts: {
-  glyphDir: string;
+/**
+ * Compile a TTF font from pre-transformed glyph data.
+ * Builds SVG font XML directly (no intermediate files), then converts via svg2ttf.
+ */
+export async function compileTtfFromGlyphs(opts: {
+  glyphs: FontGlyph[];
   outTtfPath: string;
   fontName: string;
   upm: number;
@@ -40,52 +76,20 @@ export async function compileTtfFromGlyphSVGs(opts: {
   descent: number;
   lineGap?: number;
 }): Promise<void> {
-  const { SVGIcons2SVGFontStream } = await import('svgicons2svgfont');
-
-  const { glyphDir, outTtfPath, fontName, upm, ascent, descent } = opts;
+  const { glyphs, outTtfPath, fontName, upm, ascent, descent } = opts;
   const lineGap = opts.lineGap ?? 0;
 
-  const files = fs
-    .readdirSync(glyphDir)
-    .filter((f) => /^u[0-9a-fA-F]+\.svg$/.test(f))
-    .sort(
-      (a, b) => parseCodepointFromFilename(a) - parseCodepointFromFilename(b)
-    );
-
-  if (files.length === 0)
-    throw new Error(`No glyph SVGs found in: ${glyphDir}`);
+  if (glyphs.length === 0)
+    throw new Error('No glyphs to compile');
 
-  const fontStream = new SVGIcons2SVGFontStream({
+  const svgFontString = buildSvgFontXml({
     fontName,
-    fontHeight: upm,
-    normalize: false,
+    glyphs,
+    upm,
     ascent,
     descent,
   });
 
-  const svgFontChunks: Buffer[] = [];
-  fontStream.on('data', (c: Buffer | string) =>
-    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: (err: Error) => void;
-  const fontStreamErrorPromise = new Promise<never>((_, rej) => {
-    fontStreamReject = rej;
-  });
-  fontStream.on('error', (err: Error) => fontStreamReject(err));
-
-  for (const f of files) {
-    await Promise.race([
-      writeGlyphStreamToFont(fontStream, path.join(glyphDir, f), f),
-      fontStreamErrorPromise,
-    ]);
-  }
-
-  fontStream.end();
-  await once(fontStream, 'end');
-
-  const svgFontString = Buffer.concat(svgFontChunks).toString('utf8');
   const ttfRaw = svg2ttf(svgFontString);
   const rawBuf = Buffer.from(ttfRaw.buffer);
 

package/src/core/pipeline/managers.ts

@@ -73,14 +73,37 @@ export class PyodideManager {
 
     await py.loadPackage(['micropip', 'lxml'], { messageCallback: () => {} });
 
+    // Resolve local picosvg wheel path for offline-first installation.
+    const picosvgWhlDir = path.join(
+      getPackageRoot(),
+      'src',
+      'core',
+      'shims'
+    );
+    const picosvgWhl = (await fs.readdir(picosvgWhlDir))
+      .find((f) => f.startsWith('picosvg-') && f.endsWith('.whl'));
+    const localWhlUrl = picosvgWhl
+      ? `file://${path.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
     `);