@worldcoin/nucleus 0.1.4 → 0.1.5

package/tokens/formats/colors-ios.ts

@@ -1,106 +0,0 @@
-import Handlebars from 'handlebars';
-
-import { camelCasePath, parseReference, publicColorPath, readTemplate } from './shared.js';
-import { loadColorTokens } from './loaders.js';
-import type { ColorLeaf } from './loaders.js';
-
-const PRIMITIVES_TEMPLATE = Handlebars.compile(
-  readTemplate('tokens/templates/ios/NucleusColor+Primitives.swift.hbs'),
-);
-const SEMANTICS_TEMPLATE = Handlebars.compile(
-  readTemplate('tokens/templates/ios/NucleusColor+Semantics.swift.hbs'),
-);
-
-interface PrimitiveEntry {
-  name: string;
-  hex: string;
-}
-
-interface SemanticEntry {
-  name: string;
-  lightHex: string;
-  darkHex: string;
-  sameForBoth: boolean;
-}
-
-function hexOnly(value: string): string {
-  return value.replace('#', '').toUpperCase();
-}
-
-function resolveHex(rawValue: string, primitivesByPath: Map<string, string>): string {
-  const referencePath = parseReference(rawValue);
-  if (!referencePath) return hexOnly(rawValue);
-  const resolved = primitivesByPath.get(referencePath.join('.'));
-  if (!resolved) {
-    throw new Error(`Unresolved nucleus color reference: ${rawValue}`);
-  }
-  return resolved;
-}
-
-function buildPrimitives(tokens: ColorLeaf[]): {
-  entries: PrimitiveEntry[];
-  byPath: Map<string, string>;
-} {
-  const byPath = new Map<string, string>();
-  const entries: PrimitiveEntry[] = [];
-  for (const { path, rawValue } of tokens) {
-    const hex = hexOnly(rawValue);
-    byPath.set(path.join('.'), hex);
-    entries.push({ name: camelCasePath(publicColorPath(path)), hex });
-  }
-  entries.sort((a, b) => a.name.localeCompare(b.name));
-  return { entries, byPath };
-}
-
-function buildSemantics(
-  lightTokens: ColorLeaf[],
-  darkTokens: ColorLeaf[],
-  primitivesByPath: Map<string, string>,
-): SemanticEntry[] {
-  const collectByName = (tokens: ColorLeaf[]): Map<string, string> => {
-    const out = new Map<string, string>();
-    for (const { path, rawValue } of tokens) {
-      out.set(camelCasePath(publicColorPath(path)), resolveHex(rawValue, primitivesByPath));
-    }
-    return out;
-  };
-
-  const lightByName = collectByName(lightTokens);
-  const darkByName = collectByName(darkTokens);
-
-  const allNames = new Set([...lightByName.keys(), ...darkByName.keys()]);
-  const entries: SemanticEntry[] = [];
-  for (const name of allNames) {
-    const lightHex = lightByName.get(name);
-    const darkHex = darkByName.get(name);
-    if (!lightHex || !darkHex) {
-      throw new Error(`Semantic token '${name}' missing from one of the light/dark sources`);
-    }
-    entries.push({ name, lightHex, darkHex, sameForBoth: lightHex === darkHex });
-  }
-  entries.sort((a, b) => a.name.localeCompare(b.name));
-  return entries;
-}
-
-export interface IOSColorOutput {
-  primitivesContent: string;
-  semanticsContent: string;
-}
-
-export function generateIOSColors(args: {
-  primitiveSource: string;
-  semanticLightSource: string;
-  semanticDarkSource: string;
-}): IOSColorOutput {
-  const primitiveTokens = loadColorTokens(args.primitiveSource);
-  const lightTokens = loadColorTokens(args.semanticLightSource);
-  const darkTokens = loadColorTokens(args.semanticDarkSource);
-
-  const { entries: primitiveEntries, byPath: primitivesByPath } = buildPrimitives(primitiveTokens);
-  const semanticEntries = buildSemantics(lightTokens, darkTokens, primitivesByPath);
-
-  return {
-    primitivesContent: PRIMITIVES_TEMPLATE({ tokens: primitiveEntries }),
-    semanticsContent: SEMANTICS_TEMPLATE({ tokens: semanticEntries }),
-  };
-}

package/tokens/formats/colors-web.ts

@@ -1,32 +0,0 @@
-import {
-  camelCasePath,
-  kebabCasePath,
-  parseReference,
-  publicColorPath,
-} from './shared.js';
-import type { ColorLeaf } from './loaders.js';
-
-function cssVariableName(path: string[]): string {
-  return `--nucleus-${kebabCasePath(publicColorPath(path))}`;
-}
-
-function cssColorValue(rawValue: string): string {
-  const referencePath = parseReference(rawValue);
-  if (referencePath) return `var(${cssVariableName(referencePath)})`;
-  return rawValue;
-}
-
-export function generateWebColorCss(tokens: ColorLeaf[]): string {
-  const lines = tokens.map(
-    (token) => `  ${cssVariableName(token.path)}: ${cssColorValue(token.rawValue)};`,
-  );
-  return [':root {', ...lines, '}', ''].join('\n');
-}
-
-export function generateWebColorJson(tokens: ColorLeaf[]): string {
-  const result: Record<string, string> = {};
-  for (const token of tokens) {
-    result[camelCasePath(publicColorPath(token.path))] = token.rawValue;
-  }
-  return JSON.stringify(result, null, 2) + '\n';
-}

package/tokens/formats/fonts-android.ts

@@ -1,33 +0,0 @@
-import Handlebars from 'handlebars';
-
-import { readTemplate, snakeCase } from './shared.js';
-import type { FontToken } from './loaders.js';
-
-const PACKAGE_NAME = 'com.worldcoin.nucleus.tokens';
-const TEMPLATE = Handlebars.compile(
-  readTemplate('tokens/templates/android/NucleusFonts.kt.hbs'),
-);
-
-interface AndroidFontEntry {
-  name: string;
-  fontResource: string;
-  size: string;
-  weight: number;
-  letterSpacing: string;
-  lineHeight: string;
-}
-
-function toAndroidEntry(token: FontToken): AndroidFontEntry {
-  return {
-    name: token.name,
-    fontResource: snakeCase(token.family.file),
-    size: token.size.toString(),
-    weight: token.weight,
-    letterSpacing: token.letterSpacing.toString(),
-    lineHeight: token.lineHeight.toString(),
-  };
-}
-
-export function generateAndroidFonts(tokens: FontToken[]): string {
-  return TEMPLATE({ packageName: PACKAGE_NAME, tokens: tokens.map(toAndroidEntry) });
-}

package/tokens/formats/fonts-ios.ts

@@ -1,34 +0,0 @@
-import Handlebars from 'handlebars';
-
-import { readTemplate } from './shared.js';
-import type { FontToken } from './loaders.js';
-
-const TEMPLATE = Handlebars.compile(
-  readTemplate('tokens/templates/ios/NucleusFont+Defaults.swift.hbs'),
-);
-
-interface IOSFontEntry {
-  name: string;
-  fontName: string;
-  size: string;
-  weight: string;
-  letterSpacing: string;
-  lineHeight: string;
-  dynamicTypeStyle: string;
-}
-
-function toIOSEntry(token: FontToken): IOSFontEntry {
-  return {
-    name: token.name,
-    fontName: token.family.postscriptName,
-    size: token.size.toString(),
-    weight: token.weight.toString(),
-    letterSpacing: token.letterSpacing.toString(),
-    lineHeight: token.lineHeight.toString(),
-    dynamicTypeStyle: token.dynamicTypeStyle ?? 'body',
-  };
-}
-
-export function generateIOSFonts(tokens: FontToken[]): string {
-  return TEMPLATE({ tokens: tokens.map(toIOSEntry) });
-}

package/tokens/formats/fonts-web.ts

@@ -1,44 +0,0 @@
-import { kebabCase } from './shared.js';
-import type { FontToken } from './loaders.js';
-
-export interface WebFontResult {
-  variablesCss: string;
-  json: string;
-}
-
-function variableName(token: FontToken, key: string): string {
-  return `--nucleus-font-${kebabCase(token.name)}-${key}`;
-}
-
-function buildVariablesCss(tokens: FontToken[]): string {
-  const lines: string[] = [];
-  for (const token of tokens) {
-    lines.push(`  ${variableName(token, 'family')}: "${token.family.postscriptName}";`);
-    lines.push(`  ${variableName(token, 'size')}: ${token.size}px;`);
-    lines.push(`  ${variableName(token, 'weight')}: ${token.weight};`);
-    lines.push(`  ${variableName(token, 'letter-spacing')}: ${token.letterSpacing}em;`);
-    lines.push(`  ${variableName(token, 'line-height')}: ${token.lineHeight};`);
-  }
-  return [':root {', ...lines, '}', ''].join('\n');
-}
-
-function buildJson(tokens: FontToken[]): string {
-  const result: Record<string, Record<string, string | number>> = {};
-  for (const token of tokens) {
-    result[token.name] = {
-      fontName: token.family.postscriptName,
-      size: `${token.size}px`,
-      weight: token.weight,
-      letterSpacing: `${token.letterSpacing}em`,
-      lineHeight: token.lineHeight,
-    };
-  }
-  return JSON.stringify(result, null, 2) + '\n';
-}
-
-export function generateWebFonts(tokens: FontToken[]): WebFontResult {
-  return {
-    variablesCss: buildVariablesCss(tokens),
-    json: buildJson(tokens),
-  };
-}

package/tokens/formats/icons-android.ts

@@ -1,210 +0,0 @@
-import Handlebars from 'handlebars';
-
-import { readTemplate } from './shared.js';
-import type { IconToken, IconVariant } from './icons-shared.js';
-
-const PACKAGE_NAME = 'com.worldcoin.nucleus.tokens';
-const TEMPLATE = Handlebars.compile(
-  readTemplate('tokens/templates/android/NucleusIcon.kt.hbs'),
-);
-
-// android resource names must be [a-z0-9_]; we prefix with `nucleus_icon_` so the
-// drawables don't collide with whatever the consuming app already ships.
-export const ANDROID_DRAWABLE_PREFIX = 'nucleus_icon';
-
-export function androidDrawableName(token: IconToken, variant: IconVariant): string {
-  return `${ANDROID_DRAWABLE_PREFIX}_${token.androidStem}_${variant}`;
-}
-
-// Kotlin marker interface + resource property generated for each variant an icon ships.
-// Icons that don't ship a variant simply don't implement that interface, so accessing the
-// missing variant's res property is a compile error in consuming code — no nullable res
-// IDs and no runtime variant resolution.
-const VARIANT_KOTLIN: Record<IconVariant, { markerInterface: string; property: string }> = {
-  outline: { markerInterface: 'HasOutline', property: 'outlineRes' },
-  regular: { markerInterface: 'HasRegular', property: 'regularRes' },
-  solid: { markerInterface: 'HasSolid', property: 'solidRes' },
-};
-
-interface AndroidIconEntry {
-  kotlinCase: string;
-  resourceName: string;
-  // marker interfaces for the variants this icon ships, e.g. ['HasOutline', 'HasRegular']
-  interfaces: string[];
-  // one non-null res property override per shipped variant
-  properties: Array<{ property: string; drawable: string }>;
-}
-
-function toAndroidEntry(token: IconToken): AndroidIconEntry {
-  return {
-    kotlinCase: token.kotlinCase,
-    resourceName: token.name,
-    interfaces: token.variants.map((variant) => VARIANT_KOTLIN[variant].markerInterface),
-    properties: token.variants.map((variant) => ({
-      property: VARIANT_KOTLIN[variant].property,
-      drawable: `R.drawable.${androidDrawableName(token, variant)}`,
-    })),
-  };
-}
-
-export function generateAndroidIcons(tokens: IconToken[]): string {
-  return TEMPLATE({ packageName: PACKAGE_NAME, tokens: tokens.map(toAndroidEntry) });
-}
-
-// SVG → VectorDrawable XML conversion. Our SVGs are uniform: a single <svg>
-// containing one or more <path>, <rect>, or <circle> children. The only
-// transform we encounter is a `matrix(...)` on a single rect in `gift.svg`.
-
-type Mat = readonly [number, number, number, number, number, number];
-const IDENTITY: Mat = [1, 0, 0, 1, 0, 0];
-
-function applyMat(mat: Mat, x: number, y: number): [number, number] {
-  return [mat[0] * x + mat[2] * y + mat[4], mat[1] * x + mat[3] * y + mat[5]];
-}
-
-function parseTransform(value: string | undefined): Mat {
-  if (!value) return IDENTITY;
-  const match = /matrix\(\s*([^)]+)\)/.exec(value);
-  if (!match) return IDENTITY;
-  const parts = match[1].split(/[\s,]+/).map(Number);
-  if (parts.length !== 6 || parts.some((n) => Number.isNaN(n))) {
-    throw new Error(`Unsupported svg transform: ${value}`);
-  }
-  return [parts[0], parts[1], parts[2], parts[3], parts[4], parts[5]] as const;
-}
-
-function parseAttrs(raw: string): Map<string, string> {
-  const map = new Map<string, string>();
-  const attrRegex = /([a-zA-Z][\w-]*)\s*=\s*"([^"]*)"/g;
-  let m;
-  while ((m = attrRegex.exec(raw)) !== null) {
-    map.set(m[1], m[2]);
-  }
-  return map;
-}
-
-function fmt(n: number): string {
-  // tidy up floats so the generated XML stays readable
-  return Number.isInteger(n) ? n.toString() : Number(n.toFixed(4)).toString();
-}
-
-function rectToPathData(attrs: Map<string, string>): string {
-  const x = Number(attrs.get('x') ?? '0');
-  const y = Number(attrs.get('y') ?? '0');
-  const width = Number(attrs.get('width') ?? '0');
-  const height = Number(attrs.get('height') ?? '0');
-  const mat = parseTransform(attrs.get('transform'));
-
-  const corners: Array<[number, number]> = [
-    [x, y],
-    [x + width, y],
-    [x + width, y + height],
-    [x, y + height],
-  ];
-  const transformed = corners.map(([cx, cy]) => applyMat(mat, cx, cy));
-
-  const [p0, p1, p2, p3] = transformed;
-  return `M${fmt(p0[0])},${fmt(p0[1])} L${fmt(p1[0])},${fmt(p1[1])} L${fmt(p2[0])},${fmt(p2[1])} L${fmt(p3[0])},${fmt(p3[1])} Z`;
-}
-
-function circleToPathData(attrs: Map<string, string>): string {
-  const cx = Number(attrs.get('cx') ?? '0');
-  const cy = Number(attrs.get('cy') ?? '0');
-  const r = Number(attrs.get('r') ?? '0');
-  const mat = parseTransform(attrs.get('transform'));
-
-  // we only ever apply identity transforms to circles in our icon set, so
-  // approximating with a single radius is fine
-  const [centerX, centerY] = applyMat(mat, cx, cy);
-  const start = centerX - r;
-  return `M${fmt(start)},${fmt(centerY)} a${fmt(r)},${fmt(r)} 0 1,0 ${fmt(2 * r)},0 a${fmt(r)},${fmt(r)} 0 1,0 ${fmt(-2 * r)},0 Z`;
-}
-
-interface DrawablePath {
-  pathData: string;
-  fill: boolean;
-  stroke: boolean;
-  strokeWidth: string | null;
-  strokeMiterLimit: string | null;
-}
-
-function elementToDrawablePath(tag: string, attrs: Map<string, string>): DrawablePath | null {
-  let pathData: string;
-  switch (tag) {
-    case 'path':
-      pathData = attrs.get('d') ?? '';
-      break;
-    case 'rect':
-      pathData = rectToPathData(attrs);
-      break;
-    case 'circle':
-      pathData = circleToPathData(attrs);
-      break;
-    default:
-      throw new Error(`Unsupported svg element: <${tag}>`);
-  }
-  if (!pathData) return null;
-
-  const fill = attrs.get('fill');
-  const stroke = attrs.get('stroke');
-
-  return {
-    pathData,
-    fill: fill !== undefined && fill !== 'none',
-    stroke: stroke !== undefined && stroke !== 'none',
-    strokeWidth: attrs.get('stroke-width') ?? null,
-    strokeMiterLimit: attrs.get('stroke-miterlimit') ?? null,
-  };
-}
-
-export function svgToVectorDrawable(svg: string): string {
-  const svgRoot = /<svg([^>]*)>/.exec(svg);
-  if (!svgRoot) throw new Error('Could not find <svg> root');
-  const rootAttrs = parseAttrs(svgRoot[1]);
-  const viewBox = rootAttrs.get('viewBox')?.split(/\s+/).map(Number) ?? [0, 0, 24, 24];
-  const width = viewBox[2];
-  const height = viewBox[3];
-
-  const elementRegex = /<(path|rect|circle)\b([^/>]*)\/?>/g;
-  const drawablePaths: DrawablePath[] = [];
-  let match;
-  while ((match = elementRegex.exec(svg)) !== null) {
-    const tag = match[1];
-    const attrs = parseAttrs(match[2]);
-    const path = elementToDrawablePath(tag, attrs);
-    if (path) drawablePaths.push(path);
-  }
-
-  // we hard-code black as the baseline color; consumers should tint via Compose
-  // `Icon(painter, tint = ...)` (or `setTint` on a drawable in views)
-  const placeholderColor = '#FF000000';
-
-  const pathXml = drawablePaths
-    .map((path) => {
-      const lines: string[] = [`android:pathData="${path.pathData}"`];
-      if (path.fill) {
-        lines.push(`android:fillColor="${placeholderColor}"`);
-      }
-      if (path.stroke) {
-        lines.push(`android:strokeColor="${placeholderColor}"`);
-        if (path.strokeWidth) {
-          lines.push(`android:strokeWidth="${path.strokeWidth}"`);
-        }
-        if (path.strokeMiterLimit) {
-          lines.push(`android:strokeMiterLimit="${path.strokeMiterLimit}"`);
-        }
-      }
-      return `    <path\n        ${lines.join('\n        ')} />`;
-    })
-    .join('\n');
-
-  return `<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="${width}dp"
-    android:height="${height}dp"
-    android:viewportWidth="${width}"
-    android:viewportHeight="${height}">
-${pathXml}
-</vector>
-`;
-}

package/tokens/formats/icons-ios.ts

@@ -1,100 +0,0 @@
-import Handlebars from 'handlebars';
-
-import { readTemplate } from './shared.js';
-import {
-  ICON_VARIANTS,
-  iconAssetBaseName,
-  type IconToken,
-  type IconVariant,
-} from './icons-shared.js';
-
-const TEMPLATE = Handlebars.compile(
-  readTemplate('tokens/templates/ios/NucleusIcon+Defaults.swift.hbs'),
-);
-
-interface IOSIconEntry {
-  name: string;
-  swiftCase: string;
-  availableVariantsSwift: string;
-  availableVariantsHuman: string;
-}
-
-function toIOSEntry(token: IconToken): IOSIconEntry {
-  const cases = token.variants.map((variant) => `.${variant}`).join(', ');
-  const human = token.variants.join(', ');
-
-  return {
-    name: token.name,
-    swiftCase: token.swiftCase,
-    availableVariantsSwift: cases,
-    availableVariantsHuman: human,
-  };
-}
-
-export function generateIOSIcons(tokens: IconToken[]): string {
-  return TEMPLATE({ tokens: tokens.map(toIOSEntry) });
-}
-
-// xcassets generation
-
-interface ImagesetContents {
-  images: Array<{
-    filename: string;
-    idiom: 'universal';
-  }>;
-  info: {
-    author: 'xcode';
-    version: 1;
-  };
-  properties: {
-    'preserves-vector-representation': true;
-    'template-rendering-intent': 'template';
-  };
-}
-
-interface CatalogContents {
-  info: {
-    author: 'xcode';
-    version: 1;
-  };
-}
-
-export function imagesetContentsJson(filename: string): string {
-  const contents: ImagesetContents = {
-    images: [{ filename, idiom: 'universal' }],
-    info: { author: 'xcode', version: 1 },
-    properties: {
-      'preserves-vector-representation': true,
-      'template-rendering-intent': 'template',
-    },
-  };
-  return `${JSON.stringify(contents, null, 2)}\n`;
-}
-
-export function catalogContentsJson(): string {
-  const contents: CatalogContents = {
-    info: { author: 'xcode', version: 1 },
-  };
-  return `${JSON.stringify(contents, null, 2)}\n`;
-}
-
-export interface IOSImagesetPlan {
-  name: string; // imageset directory name without extension
-  variant: IconVariant;
-  iconName: string; // kebab-case icon name (used to locate svg source)
-}
-
-export function planIOSImagesets(tokens: IconToken[]): IOSImagesetPlan[] {
-  const plans: IOSImagesetPlan[] = [];
-  for (const token of tokens) {
-    for (const variant of ICON_VARIANTS) {
-      if (!token.variants.includes(variant)) continue;
-      plans.push({
-        name: iconAssetBaseName(token.name, variant),
-        variant,
-        iconName: token.name,
-      });
-    }
-  }
-  return plans;
-}

package/tokens/formats/icons-shared.ts

@@ -1,72 +0,0 @@
-import { readdirSync, readFileSync } from 'fs';
-import { resolve, dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
-
-export const ICON_DEFINITIONS_DIR = 'tokens/definitions/icons';
-export const ICON_VARIANTS = ['outline', 'regular', 'solid'] as const;
-export type IconVariant = (typeof ICON_VARIANTS)[number];
-
-export interface IconToken {
-  // kebab-case identifier — also the asset filename and Swift raw value
-  name: string;
-  // camelCase Swift case name
-  swiftCase: string;
-  // PascalCase Kotlin enum entry name
-  kotlinCase: string;
-  // snake_case stem used in android resource filenames
-  androidStem: string;
-  // variants this icon ships in (subset of ICON_VARIANTS)
-  variants: IconVariant[];
-}
-
-function kebabToCamel(name: string): string {
-  return name.replace(/-([a-z0-9])/g, (_, c: string) => c.toUpperCase());
-}
-
-function kebabToPascal(name: string): string {
-  const camel = kebabToCamel(name);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-
-function kebabToSnake(name: string): string {
-  return name.replace(/-/g, '_');
-}
-
-export function discoverIconTokens(): IconToken[] {
-  const seen = new Map<string, Set<IconVariant>>();
-
-  for (const variant of ICON_VARIANTS) {
-    const dir = resolve(ROOT, ICON_DEFINITIONS_DIR, variant);
-    const files = readdirSync(dir).filter((file) => file.toLowerCase().endsWith('.svg'));
-    for (const file of files) {
-      const name = file.replace(/\.svg$/i, '');
-      let variants = seen.get(name);
-      if (!variants) {
-        variants = new Set();
-        seen.set(name, variants);
-      }
-      variants.add(variant);
-    }
-  }
-
-  return [...seen.entries()]
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([name, variants]) => ({
-      name,
-      swiftCase: kebabToCamel(name),
-      kotlinCase: kebabToPascal(name),
-      androidStem: kebabToSnake(name),
-      variants: ICON_VARIANTS.filter((variant) => variants.has(variant)),
-    }));
-}
-
-export function readIconSvg(variant: IconVariant, name: string): string {
-  const path = resolve(ROOT, ICON_DEFINITIONS_DIR, variant, `${name}.svg`);
-  return readFileSync(path, 'utf8');
-}
-
-export function iconAssetBaseName(name: string, variant: IconVariant): string {
-  return `${name}-${variant}`;
-}

package/tokens/formats/icons-web.ts

@@ -1,36 +0,0 @@
-import { type IconToken, type IconVariant, ICON_VARIANTS, iconAssetBaseName, readIconSvg } from './icons-shared.js';
-
-export interface WebIconEntry {
-  name: string;
-  // map of variant → relative path to the svg file (relative to the package root)
-  files: Partial<Record<IconVariant, string>>;
-  // map of variant → inlined svg source (handy for direct-paste use)
-  svg: Partial<Record<IconVariant, string>>;
-}
-
-const ICON_FOLDER = 'icons';
-
-export function planWebIcons(tokens: IconToken[]): WebIconEntry[] {
-  return tokens.map((token) => {
-    const files: Partial<Record<IconVariant, string>> = {};
-    const svg: Partial<Record<IconVariant, string>> = {};
-
-    for (const variant of ICON_VARIANTS) {
-      if (!token.variants.includes(variant)) continue;
-      const filename = `${iconAssetBaseName(token.name, variant)}.svg`;
-      files[variant] = `${ICON_FOLDER}/${filename}`;
-      svg[variant] = readIconSvg(variant, token.name).trim();
-    }
-
-    return { name: token.name, files, svg };
-  });
-}
-
-export function generateWebIconsManifest(tokens: IconToken[]): string {
-  const entries = planWebIcons(tokens);
-  const indexedByName: Record<string, Pick<WebIconEntry, 'files' | 'svg'>> = {};
-  for (const entry of entries) {
-    indexedByName[entry.name] = { files: entry.files, svg: entry.svg };
-  }
-  return `${JSON.stringify(indexedByName, null, 2)}\n`;
-}