@moewolf/moe-icons-cli 0.0.1

package/dist/generator/generate.js

@@ -0,0 +1,562 @@
+import { catalog, findCatalogIcon } from "../catalog/catalog.js";
+import { reportLibraryExportNameCollisions, reportProxyNameCollisions, toLibraryExportName, toProxyName, } from "../core/icon-names.js";
+import { selectBitmapVariantAssets } from "../core/bitmap-assets.js";
+import { createHash } from "node:crypto";
+import { decodeUtf8 } from "../project/tar-gz.js";
+import { CN_HELPER_SOURCE } from "./cn.js";
+import { bitmapWrapperImportName, reactBitmapWrapperSource, resolveThemes, svgInternalImportName, vueBitmapWrapperSource, } from "./theme-resolve.js";
+export { toLibraryExportName, toProxyName };
+/** @deprecated Use toProxyName; kept so existing generator tests keep compiling. */
+export const toPascalCase = toProxyName;
+const OWNER_HEADER = "// Generated by moeicons CLI. Do not edit manually; re-run `moeicons generate`.";
+function themeClassExpr(themes) {
+    const entries = themes
+        .map((theme) => {
+        const className = theme.entry.className;
+        return `  ${JSON.stringify(theme.theme)}: ${className === undefined ? "undefined" : JSON.stringify(className)},`;
+    })
+        .join("\n");
+    return `const themeClassName: Partial<Record<Theme, string | undefined>> = {\n${entries}\n};\n`;
+}
+function appendReactFiles(files, rel, config, themes) {
+    files.push({
+        path: rel("cn.ts"),
+        content: CN_HELPER_SOURCE,
+    });
+    files.push({
+        path: rel("types.ts"),
+        content: `${OWNER_HEADER}
+export interface IconProps {
+  className?: string;
+  size?: number;
+  strokeWidth?: number;
+  "aria-label"?: string;
+  [key: string]: unknown;
+}
+export type Theme =
+${Object.keys(config.themes)
+            .map((theme) => `  | ${JSON.stringify(theme)}`)
+            .join("\n")};
+`,
+    });
+    const importLines = [];
+    for (const resolved of themes) {
+        if (resolved.kind === "svg") {
+            for (const iconId of config.icons) {
+                const alias = svgInternalImportName(resolved.theme, resolved.entry.styleGroup, iconId);
+                importLines.push(`import { ${toLibraryExportName(iconId)} as ${alias} } from "moe-icons/${config.tier}/react/${resolved.entry.styleGroup}";`);
+            }
+        }
+        else if (resolved.variant) {
+            for (const iconId of config.icons) {
+                const wrapperName = bitmapWrapperImportName(resolved.theme, iconId);
+                const wrapperPath = `./wrappers/${wrapperName}`;
+                importLines.push(`import { ${wrapperName} } from "${wrapperPath}";`);
+                files.push({
+                    path: rel(`wrappers/${wrapperName}.tsx`),
+                    content: `${OWNER_HEADER}
+${reactBitmapWrapperSource(iconId, wrapperName, resolved.variant, resolved.entry.className)}`,
+                });
+            }
+        }
+    }
+    files.push({
+        path: rel("registry.ts"),
+        content: `${OWNER_HEADER}
+import type { IconProps, Theme } from "./types";
+import type * as React from "react";
+${importLines.join("\n")}
+
+export type IconId =
+${config.icons.map((id) => `  | "${id}"`).join("\n")};
+
+export interface ThemeRegistry {
+${config.icons.map((id) => `  readonly ${toPascalCase(id)}: React.ComponentType<IconProps>;`).join("\n")}
+}
+
+export const registry: Record<Theme, ThemeRegistry> = {
+${themes
+            .map((resolved) => {
+            const entries = config.icons
+                .map((id) => {
+                const component = resolved.kind === "bitmap"
+                    ? bitmapWrapperImportName(resolved.theme, id)
+                    : svgInternalImportName(resolved.theme, resolved.entry.styleGroup, id);
+                return `    ${toPascalCase(id)}: ${component},`;
+            })
+                .join("\n");
+            return `  "${resolved.theme}": {\n${entries}\n  },`;
+        })
+            .join("\n")}
+};
+`,
+    });
+    files.push({
+        path: rel("provider.tsx"),
+        content: `${OWNER_HEADER}
+import { createContext, useContext, useState, type PropsWithChildren } from "react";
+import type { Theme } from "./types";
+
+interface MoeiconsThemeState { readonly theme: Theme; readonly setTheme: (theme: Theme) => void; }
+const MoeiconsThemeContext = createContext<MoeiconsThemeState | undefined>(undefined);
+export function MoeiconsProvider(props: PropsWithChildren<{ theme?: Theme }>) {
+  const [theme, setTheme] = useState<Theme>(props.theme ?? ${JSON.stringify(config.defaultTheme)});
+  return <MoeiconsThemeContext.Provider value={{ theme, setTheme }}>{props.children}</MoeiconsThemeContext.Provider>;
+}
+export function useMoeiconsTheme(): MoeiconsThemeState {
+  const state = useContext(MoeiconsThemeContext);
+  if (!state) throw new Error("useMoeiconsTheme must be used inside <MoeiconsProvider>");
+  return state;
+}
+`,
+    });
+    for (const iconId of config.icons) {
+        const pascal = toPascalCase(iconId);
+        files.push({
+            path: rel(`icons/${pascal}.tsx`),
+            content: `${OWNER_HEADER}
+import type { IconProps } from "../types";
+import { registry } from "../registry";
+import { useMoeiconsTheme } from "../provider";
+import { cn } from "../cn";
+import type { Theme } from "../types";
+
+${themeClassExpr(themes)}
+
+export function ${pascal}(props: IconProps) {
+  const { className, size, ...rest } = props;
+  const { theme } = useMoeiconsTheme();
+  const Component = registry[theme]?.${pascal} ?? registry[${JSON.stringify(config.defaultTheme)}].${pascal};
+  const sizeClass = typeof size === "number" ? \`w-[\${size}px] h-[\${size}px]\` : undefined;
+  return <Component {...rest} size={size} className={cn("moe-icon", themeClassName[theme as Theme], sizeClass, className)} />;
+}
+`,
+        });
+    }
+    files.push({
+        path: rel("index.ts"),
+        content: `${OWNER_HEADER}
+export type { IconProps } from "./types";
+export { cn } from "./cn";
+export { MoeiconsProvider, useMoeiconsTheme } from "./provider";
+${config.icons.map((id) => `export { ${toPascalCase(id)} } from "./icons/${toPascalCase(id)}";`).join("\n")}
+`,
+    });
+}
+function appendVueFiles(files, rel, config, themes) {
+    files.push({
+        path: rel("cn.ts"),
+        content: CN_HELPER_SOURCE,
+    });
+    files.push({
+        path: rel("types.ts"),
+        content: `${OWNER_HEADER}
+export interface IconProps {
+  class?: string;
+  size?: number;
+  strokeWidth?: number;
+  "aria-label"?: string;
+  [key: string]: unknown;
+}
+
+export type Theme =
+${Object.keys(config.themes)
+            .map((theme) => `  | ${JSON.stringify(theme)}`)
+            .join("\n")};
+`,
+    });
+    files.push({
+        path: rel("theme.ts"),
+        content: `${OWNER_HEADER}
+import type { InjectionKey, Ref } from "vue";
+import type { Theme } from "./types";
+
+export interface MoeiconsThemeState {
+  readonly theme: Ref<Theme>;
+  readonly setTheme: (theme: Theme) => void;
+}
+
+export const MOEICONS_THEME_KEY: InjectionKey<MoeiconsThemeState> = Symbol("moeicons-theme");
+`,
+    });
+    const importLines = [];
+    for (const resolved of themes) {
+        if (resolved.kind === "svg") {
+            for (const iconId of config.icons) {
+                const alias = svgInternalImportName(resolved.theme, resolved.entry.styleGroup, iconId);
+                importLines.push(`import { ${toLibraryExportName(iconId)} as ${alias} } from "moe-icons/${config.tier}/vue/${resolved.entry.styleGroup}";`);
+            }
+        }
+        else if (resolved.variant) {
+            for (const iconId of config.icons) {
+                const wrapperName = bitmapWrapperImportName(resolved.theme, iconId);
+                importLines.push(`import { ${wrapperName} } from "./wrappers/${wrapperName}";`);
+                files.push({
+                    path: rel(`wrappers/${wrapperName}.ts`),
+                    content: `${OWNER_HEADER}
+${vueBitmapWrapperSource(iconId, wrapperName, resolved.variant, resolved.entry.className)}`,
+                });
+            }
+        }
+    }
+    files.push({
+        path: rel("registry.ts"),
+        content: `${OWNER_HEADER}
+import type { Component } from "vue";
+import type { Theme } from "./types";
+${importLines.join("\n")}
+
+export type IconId =
+${config.icons.map((id) => `  | "${id}"`).join("\n")};
+
+export interface ThemeRegistry {
+${config.icons.map((id) => `  readonly ${toPascalCase(id)}: Component;`).join("\n")}
+}
+
+export const registry: Record<Theme, ThemeRegistry> = {
+${themes
+            .map((resolved) => {
+            const entries = config.icons
+                .map((id) => {
+                const component = resolved.kind === "bitmap"
+                    ? bitmapWrapperImportName(resolved.theme, id)
+                    : svgInternalImportName(resolved.theme, resolved.entry.styleGroup, id);
+                return `    ${toPascalCase(id)}: ${component},`;
+            })
+                .join("\n");
+            return `  "${resolved.theme}": {\n${entries}\n  },`;
+        })
+            .join("\n")}
+};
+`,
+    });
+    files.push({
+        path: rel("provider.ts"),
+        content: `${OWNER_HEADER}
+import { defineComponent, provide, ref, type PropType } from "vue";
+import type { Theme } from "./types";
+import { MOEICONS_THEME_KEY, type MoeiconsThemeState } from "./theme";
+
+export const MoeiconsProvider = defineComponent({
+  name: "MoeiconsProvider",
+  props: {
+    theme: { type: String as PropType<Theme>, default: ${JSON.stringify(config.defaultTheme)} as Theme },
+  },
+  setup(props, { slots }) {
+    const theme = ref<Theme>(props.theme);
+    const setTheme = (next: Theme) => {
+      theme.value = next;
+    };
+    const state: MoeiconsThemeState = { theme, setTheme };
+    provide(MOEICONS_THEME_KEY, state);
+    return () => slots.default?.();
+  },
+});
+`,
+    });
+    files.push({
+        path: rel("composable.ts"),
+        content: `${OWNER_HEADER}
+import { inject } from "vue";
+import { MOEICONS_THEME_KEY } from "./theme";
+import type { MoeiconsThemeState } from "./theme";
+
+export function useMoeiconsTheme(): MoeiconsThemeState {
+  const state = inject(MOEICONS_THEME_KEY);
+  if (!state) {
+    throw new Error("useMoeiconsTheme must be used inside <MoeiconsProvider>");
+  }
+  return state;
+}
+`,
+    });
+    for (const iconId of config.icons) {
+        const pascal = toPascalCase(iconId);
+        files.push({
+            path: rel(`icons/${pascal}.ts`),
+            content: `${OWNER_HEADER}
+import { computed, defineComponent, h, inject } from "vue";
+import { MOEICONS_THEME_KEY, type MoeiconsThemeState } from "../theme";
+import { registry } from "../registry";
+import { cn } from "../cn";
+import type { Theme } from "../types";
+
+${themeClassExpr(themes)}
+
+export const ${pascal} = defineComponent({
+  name: "${pascal}",
+  setup(_props, { attrs }) {
+    const state = inject<MoeiconsThemeState | undefined>(MOEICONS_THEME_KEY, undefined);
+    const component = computed(() => registry[(state?.theme.value ?? ${JSON.stringify(config.defaultTheme)}) as Theme]?.${pascal} ?? registry[${JSON.stringify(config.defaultTheme)}].${pascal});
+    return () => {
+      const className = typeof attrs.class === "string" ? attrs.class : undefined;
+      const size = typeof attrs.size === "number" ? attrs.size : undefined;
+      const sizeClass = typeof size === "number" ? \`w-[\${size}px] h-[\${size}px]\` : undefined;
+      const theme = (state?.theme.value ?? ${JSON.stringify(config.defaultTheme)}) as Theme;
+      return h(component.value, {
+        ...attrs,
+        class: cn("moe-icon", themeClassName[theme], sizeClass, className),
+      });
+    };
+  },
+});
+`,
+        });
+    }
+    files.push({
+        path: rel("index.ts"),
+        content: `${OWNER_HEADER}
+export type { IconProps } from "./types";
+export { cn } from "./cn";
+export { MOEICONS_THEME_KEY, type MoeiconsThemeState } from "./theme";
+export { useMoeiconsTheme } from "./composable";
+export { MoeiconsProvider } from "./provider";
+${config.icons
+            .map((id) => `export { ${toPascalCase(id)} } from "./icons/${toPascalCase(id)}";`)
+            .join("\n")}
+`,
+    });
+}
+function parseSvgNodes(source) {
+    const root = { children: [] };
+    const stack = [root];
+    const svg = source.match(/<svg\b[^>]*>/i);
+    if (!svg)
+        throw new Error("SVG root element is missing");
+    const viewBox = svg[0].match(/\bviewBox\s*=\s*["']([^"']+)["']/i)?.[1] ?? "0 0 24 24";
+    const inner = source.slice((svg.index ?? 0) + svg[0].length).replace(/<\/svg>\s*$/i, "");
+    const tokenRe = /<!--[\s\S]*?-->|<[^>]+>|[^<]+/g;
+    for (const match of inner.matchAll(tokenRe)) {
+        const token = match[0];
+        if (token.startsWith("<!--") || !token.trim())
+            continue;
+        if (token.startsWith("</")) {
+            if (stack.length > 1)
+                stack.pop();
+            continue;
+        }
+        if (!token.startsWith("<")) {
+            stack[stack.length - 1]?.children.push({ text: token });
+            continue;
+        }
+        const selfClosing = /\/\s*>$/.test(token);
+        const body = token.slice(1, token.length - (selfClosing ? 2 : 1)).trim();
+        const name = body.match(/^[A-Za-z][\w:.-]*/)?.[0];
+        if (!name)
+            continue;
+        const attrs = [];
+        body.slice(name.length).replace(/([A-Za-z_:][\w:.-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g, (_full, attr, doubleValue, singleValue, bareValue) => {
+            attrs.push([attr, doubleValue ?? singleValue ?? bareValue ?? ""]);
+            return "";
+        });
+        const node = { name, attrs, children: [] };
+        stack[stack.length - 1]?.children.push(node);
+        if (!selfClosing)
+            stack.push(node);
+    }
+    return { viewBox, children: root.children };
+}
+function vanillaFactorySource(name, source, strategy) {
+    const parsed = parseSvgNodes(source);
+    const paint = strategy === "solid" ? [["fill", "currentColor"]] : strategy === "outline" ? [["stroke", "currentColor"], ["fill", "none"]] : [];
+    const graphic = new Set(["path", "circle", "ellipse", "line", "polyline", "polygon", "rect", "text", "use", "image"]);
+    const lines = [
+        "const SVG_NS = 'http://www.w3.org/2000/svg';", "",
+        "export interface VanillaIconOptions extends Record<string, string | number | undefined> { className?: string; strokeWidth?: number; }", "",
+        `export function create${name}(options: VanillaIconOptions = {}): SVGElement {`,
+        "  const svg = document.createElementNS(SVG_NS, 'svg');",
+        `  svg.setAttribute('viewBox', ${JSON.stringify(parsed.viewBox)});`,
+        "  svg.setAttribute('class', options.className ? `moe-icon ${options.className}` : 'moe-icon');",
+    ];
+    for (const [attr, value] of paint)
+        lines.push(`  svg.setAttribute(${JSON.stringify(attr)}, ${JSON.stringify(value)});`);
+    lines.push("  if (options.strokeWidth !== undefined) svg.setAttribute('stroke-width', String(options.strokeWidth));");
+    lines.push("  for (const [name, value] of Object.entries(options)) if (name !== 'className' && name !== 'strokeWidth' && value !== undefined) svg.setAttribute(name, String(value));");
+    let counter = 0;
+    const emit = (nodes, parent) => {
+        for (const node of nodes) {
+            if ("text" in node) {
+                lines.push(`  ${parent}.appendChild(document.createTextNode(${JSON.stringify(node.text)}));`);
+                continue;
+            }
+            const variable = `node${counter++}`;
+            lines.push(`  const ${variable} = document.createElementNS(SVG_NS, ${JSON.stringify(node.name)});`);
+            for (const [attr, value] of node.attrs)
+                lines.push(`  ${variable}.setAttribute(${JSON.stringify(attr)}, ${JSON.stringify(value)});`);
+            if (graphic.has(node.name.toLowerCase())) {
+                if (strategy === "outline" && !node.attrs.some(([attr]) => attr.toLowerCase() === "stroke"))
+                    lines.push(`  ${variable}.setAttribute('stroke', 'currentColor');`);
+                if (strategy === "outline" && !node.attrs.some(([attr]) => attr.toLowerCase() === "fill"))
+                    lines.push(`  ${variable}.setAttribute('fill', 'none');`);
+                if (strategy === "solid" && !node.attrs.some(([attr]) => attr.toLowerCase() === "fill"))
+                    lines.push(`  ${variable}.setAttribute('fill', 'currentColor');`);
+            }
+            emit(node.children, variable);
+            lines.push(`  ${parent}.appendChild(${variable});`);
+        }
+    };
+    emit(parsed.children, "svg");
+    lines.push("  return svg;", "}", "", `export default create${name};`, "");
+    return lines.join("\n");
+}
+function archiveManifest(archiveFiles) {
+    const entry = Object.entries(archiveFiles).find(([path]) => /(?:^|\/)assets\/manifest\.json$/.test(path));
+    if (!entry)
+        return undefined;
+    try {
+        const parsed = JSON.parse(decodeUtf8(entry[1]));
+        if (parsed.schemaVersion !== 1 || !Array.isArray(parsed.assets))
+            return undefined;
+        const assets = parsed.assets.filter((asset) => typeof asset.path === "string" && typeof asset.size === "number" && Number.isSafeInteger(asset.size) && asset.size >= 0 && typeof asset.sha256 === "string");
+        return { path: entry[0], assets };
+    }
+    catch {
+        return undefined;
+    }
+}
+function sha256Hex(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function selectRawAssets(archiveFiles, themes, icons) {
+    const manifest = archiveManifest(archiveFiles);
+    if (!manifest)
+        return { ok: false, errors: ["installed artifact assets manifest is missing or invalid"] };
+    const base = manifest.path.slice(0, manifest.path.lastIndexOf("/"));
+    const wanted = new Set(themes.filter((theme) => theme.kind === "svg").flatMap((theme) => icons.map((icon) => `${theme.entry.styleGroup}/${icon}.svg`)));
+    const assets = [];
+    const errors = [];
+    for (const path of wanted) {
+        const entry = manifest.assets.find((asset) => asset.path === path);
+        const bytes = entry ? archiveFiles[`${base}/${entry.path}`] ?? archiveFiles[entry.path] : undefined;
+        if (!entry || !bytes) {
+            errors.push(`raw asset missing: ${path}`);
+            continue;
+        }
+        const sizeOk = bytes.byteLength === entry.size;
+        const shaOk = sha256Hex(bytes) === entry.sha256.toLowerCase();
+        if (!sizeOk || !shaOk) {
+            errors.push(`raw asset verification failed for ${path}: expected size ${entry.size}/sha256 ${entry.sha256}, got size ${bytes.byteLength}/sha256 ${sha256Hex(bytes)}`);
+            continue;
+        }
+        assets.push({ path: `assets/${entry.path}`, content: bytes });
+    }
+    if (errors.length > 0)
+        return { ok: false, errors };
+    return { ok: true, assets };
+}
+/**
+ * Plan generated files for a config. Returns only owned paths under the config
+ * output dir. Rejects duplicate PascalCase names and a config with no themes.
+ * Theme keys stay logical style themes; bitmap resourceVariantId never becomes a theme.
+ */
+export function planGeneratedFiles(config, outputDir, options = {}) {
+    const errors = [];
+    if (Object.keys(config.themes).length === 0) {
+        errors.push("config has no themes");
+    }
+    if (config.icons.length === 0) {
+        errors.push("config has no icons");
+    }
+    errors.push(...reportProxyNameCollisions(config.icons));
+    errors.push(...reportLibraryExportNameCollisions(config.icons));
+    for (const iconId of config.icons) {
+        const catalogIcon = findCatalogIcon(iconId, options.catalog ?? catalog);
+        if (!catalogIcon) {
+            errors.push(`unknown icon "${iconId}"`);
+            continue;
+        }
+        for (const [theme, entry] of Object.entries(config.themes)) {
+            if (!catalogIcon.availableIn.includes(entry.styleGroup)) {
+                errors.push(`icon "${iconId}" is not available in style group "${entry.styleGroup}" for theme "${theme}"`);
+            }
+        }
+    }
+    const resolved = resolveThemes(config, options.catalog ?? catalog);
+    if (!resolved.ok)
+        errors.push(...resolved.errors);
+    if (errors.length > 0 || !resolved.ok)
+        return { ok: false, errors };
+    const files = [];
+    const rel = (p) => `${outputDir.replace(/\/$/, "")}/${p}`;
+    const target = config.target;
+    if (target === "assets") {
+        // Assets are a raw-resource target; never emit wrapper code for it.
+    }
+    else if (target === "vanilla") {
+        if (resolved.themes.some((theme) => theme.kind === "bitmap")) {
+            return { ok: false, errors: ["vanilla target supports SVG themes only"] };
+        }
+        if (options.archiveFiles === undefined) {
+            return { ok: false, errors: ["vanilla target requires an installed artifact"] };
+        }
+        const raw = selectRawAssets(options.archiveFiles, resolved.themes, config.icons);
+        if (!raw.ok)
+            return raw;
+        const rawByPath = new Map(raw.assets.map((file) => [file.path.replace(/^assets\//, ""), file.content]));
+        const groups = new Set(resolved.themes.map((theme) => theme.entry.styleGroup));
+        files.push({ path: rel("types.ts"), content: "export interface VanillaIconOptions extends Record<string, string | number | undefined> { className?: string; strokeWidth?: number; }\n" });
+        for (const styleGroup of groups) {
+            const exports = ["// Vanilla factory exports"];
+            for (const iconId of config.icons) {
+                const name = toPascalCase(iconId);
+                const source = rawByPath.get(`${styleGroup}/${iconId}.svg`);
+                if (!source || typeof source === "string")
+                    return { ok: false, errors: [`raw asset missing: ${styleGroup}/${iconId}.svg`] };
+                const strategy = styleGroup.endsWith("-outline") ? "outline" : styleGroup.endsWith("-solid") ? "solid" : "mixed";
+                files.push({ path: rel(`${styleGroup}/${name}.ts`), content: vanillaFactorySource(name, decodeUtf8(source), strategy) });
+                exports.push(`export { default as ${toLibraryExportName(iconId)}, create${name} } from './${name}';`);
+            }
+            files.push({ path: rel(`${styleGroup}/index.ts`), content: `${exports.join("\n")}\n` });
+        }
+        files.push({ path: rel("index.ts"), content: `${[...groups].map((group) => `export * from './${group}';`).join("\n")}\n` });
+    }
+    else if (target === "vue") {
+        appendVueFiles(files, rel, config, resolved.themes);
+    }
+    else {
+        appendReactFiles(files, rel, config, resolved.themes);
+    }
+    if (target === "assets") {
+        if (options.archiveFiles === undefined) {
+            return { ok: false, errors: ["assets target requires an installed artifact"] };
+        }
+        const raw = selectRawAssets(options.archiveFiles, resolved.themes, config.icons);
+        if (!raw.ok)
+            return raw;
+        for (const asset of raw.assets)
+            files.push({ path: rel(asset.path), content: asset.content });
+    }
+    const bitmapThemes = resolved.themes.filter((theme) => theme.kind === "bitmap" && theme.variant);
+    if (bitmapThemes.length > 0) {
+        const variants = bitmapThemes.flatMap((theme) => (theme.variant ? [theme.variant] : []));
+        const unique = [
+            ...new Map(variants.map((variant) => [variant.resourceVariantId, variant])).values(),
+        ];
+        if (options.archiveFiles === undefined) {
+            return {
+                ok: false,
+                errors: [
+                    "bitmap themes require a downloaded free artifact; run `moeicons install` or provide a local archive fixture",
+                ],
+            };
+        }
+        const selected = selectBitmapVariantAssets(options.archiveFiles, unique, config.icons);
+        if (!selected.ok)
+            return { ok: false, errors: [...selected.errors] };
+        for (const asset of selected.assets) {
+            files.push({ path: rel(asset.destRel), content: asset.bytes });
+        }
+    }
+    if (target === "assets") {
+        const manifestAssets = files
+            .filter((file) => file.path.startsWith(`${outputDir.replace(/\/$/, "")}/assets/`) && !file.path.endsWith("/manifest.json"))
+            .map((file) => {
+            const path = file.path.slice(`${outputDir.replace(/\/$/, "")}/assets/`.length);
+            const bytes = typeof file.content === "string" ? Buffer.from(file.content, "utf8") : Buffer.from(file.content);
+            return { path, size: bytes.byteLength, sha256: createHash("sha256").update(bytes).digest("hex") };
+        })
+            .sort((a, b) => a.path.localeCompare(b.path));
+        files.push({ path: rel("assets/manifest.json"), content: `${JSON.stringify({ schemaVersion: 1, assets: manifestAssets }, null, 2)}\n` });
+    }
+    return { ok: true, files };
+}

package/dist/generator/theme-resolve.d.ts

@@ -0,0 +1,26 @@
+import { type CatalogStyleGroup, type IconCatalog } from "../catalog/catalog.js";
+import type { MoeiconsConfigFile, MoeiconsThemeConfig } from "../project/config.js";
+import { type ResourceVariant } from "../core/resource-variant.js";
+import { toLibraryExportName, toProxyName } from "../core/icon-names.js";
+export type ThemeKind = "svg" | "bitmap";
+export interface ResolvedTheme {
+    readonly theme: string;
+    readonly entry: MoeiconsThemeConfig;
+    readonly kind: ThemeKind;
+    readonly group: CatalogStyleGroup;
+    readonly variant?: ResourceVariant;
+}
+export declare function resolveThemes(config: MoeiconsConfigFile, sourceCatalog?: IconCatalog): {
+    readonly ok: true;
+    readonly themes: ResolvedTheme[];
+} | {
+    readonly ok: false;
+    readonly errors: string[];
+};
+export declare function bitmapWrapperImportName(theme: string, iconId: string): string;
+export declare function svgInternalImportName(theme: string, styleGroup: string, iconId: string): string;
+/** Relative import from icons/Foo.tsx → assets/... */
+export declare function relativeAssetImportFromIcons(variant: ResourceVariant, iconId: string): string;
+export declare function reactBitmapWrapperSource(iconId: string, wrapperName: string, variant: ResourceVariant, themeClassName: string | undefined): string;
+export declare function vueBitmapWrapperSource(iconId: string, wrapperName: string, variant: ResourceVariant, themeClassName: string | undefined): string;
+export { toLibraryExportName, toProxyName };