@moewolf/moe-icons-cli 0.0.1 → 0.0.3

package/dist/generator/shared/SOURCE.json

@@ -0,0 +1,7 @@
+{
+  "sourceRepo": "moewolf-dev/moe-icons-code-library",
+  "sourcePath": "scripts/svg-model.cjs",
+  "sourceCommit": "d8342a7b94ab18aab0581c23ca9e8be919eed8e1",
+  "sourceCommitExact": true,
+  "sha256": "f03ef4ef87898d5ec74047b2acd62a74656ed094ba484571ad0f8736c3a265fb"
+}

package/dist/generator/shared/svg-model.cjs

@@ -0,0 +1,156 @@
+'use strict';
+
+// Canonical, dependency-free XML subset for SVG generation. No DTD/entity
+// expansion or browser DOM dependency; malformed input fails before emission.
+function decodeXml(value) {
+  return value.replace(/&([^;\s<]*);|&/g, (whole, entity) => {
+    const named = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+    if (Object.hasOwn(named, entity)) return named[entity];
+    if (entity && /^#(?:x[0-9a-f]+|[0-9]+)$/i.test(entity)) {
+      const point = entity[1].toLowerCase() === 'x' ? parseInt(entity.slice(2), 16) : Number(entity.slice(1));
+      if (point === 9 || point === 10 || point === 13 || (point >= 32 && point <= 0x10ffff && !(point >= 0xd800 && point <= 0xdfff) && point !== 0xfffe && point !== 0xffff)) return String.fromCodePoint(point);
+    }
+    throw new Error(`unsupported or invalid XML entity: ${whole}`);
+  });
+}
+
+function escapeXml(value) {
+  return String(value).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+function parseAttributes(source) {
+  const attrs = [];
+  const seen = new Set();
+  let rest = source;
+  while (rest.trim()) {
+    const match = /^\s+([A-Za-z_:][\w:.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/.exec(rest);
+    if (!match) throw new Error(`invalid SVG attribute syntax: ${rest.slice(0, 80)}`);
+    const name = match[1];
+    if (seen.has(name)) throw new Error(`duplicate SVG attribute: ${name}`);
+    if (/^on/i.test(name)) throw new Error(`unsupported SVG event attribute: ${name}`);
+    seen.add(name);
+    const encoded = match[2] ?? match[3];
+    if (encoded.includes('<')) throw new Error(`invalid XML attribute: ${name}`);
+    attrs.push([name, decodeXml(encoded)]);
+    rest = rest.slice(match[0].length);
+  }
+  return attrs;
+}
+
+function parseNodes(source) {
+  const root = { children: [] };
+  const stack = [root];
+  let index = 0;
+  while (index < source.length) {
+    if (source.startsWith('<!--', index)) {
+      const end = source.indexOf('-->', index + 4);
+      if (end < 0 || source.slice(index + 4, end).includes('--')) throw new Error('invalid XML comment');
+      index = end + 3;
+      continue;
+    }
+    if (source.startsWith('<![CDATA[', index)) {
+      const end = source.indexOf(']]>', index + 9);
+      if (end < 0) throw new Error('unclosed SVG CDATA');
+      stack.at(-1).children.push({ text: source.slice(index + 9, end) });
+      index = end + 3;
+      continue;
+    }
+    if (source.startsWith('<?xml', index) && index === 0) {
+      const end = source.indexOf('?>', index + 5);
+      if (end < 0) throw new Error('unclosed XML declaration');
+      index = end + 2;
+      continue;
+    }
+    if (source[index] !== '<') {
+      const end = source.indexOf('<', index);
+      const text = decodeXml(source.slice(index, end < 0 ? source.length : end));
+      // Formatting whitespace outside text nodes has no SVG paint semantics.
+      if (text.trim() || ['text', 'tspan'].includes(stack.at(-1).name)) stack.at(-1).children.push({ text });
+      index = end < 0 ? source.length : end;
+      continue;
+    }
+    let end = index + 1;
+    let quote;
+    for (; end < source.length; end++) {
+      const character = source[end];
+      if (quote) { if (character === quote) quote = undefined; }
+      else if (character === '"' || character === "'") quote = character;
+      else if (character === '>') break;
+    }
+    if (end === source.length) throw new Error('unclosed SVG tag');
+    const tag = source.slice(index + 1, end);
+    if (tag.startsWith('/')) {
+      const name = tag.slice(1).trim();
+      if (stack.length === 1 || stack.at(-1).name !== name) throw new Error(`mismatched SVG closing tag: ${name}`);
+      stack.pop();
+    } else {
+      const selfClosing = /\/\s*$/.test(tag);
+      const body = selfClosing ? tag.replace(/\/\s*$/, '') : tag;
+      const match = /^([A-Za-z_][\w:.-]*)/.exec(body);
+      if (!match || /^(?:script|foreignObject)$/i.test(match[1])) throw new Error(`unsupported SVG element: ${body.slice(0, 80)}`);
+      const node = { name: match[1], attrs: parseAttributes(body.slice(match[0].length)), children: [] };
+      stack.at(-1).children.push(node);
+      if (!selfClosing) stack.push(node);
+    }
+    index = end + 1;
+  }
+  if (stack.length !== 1) throw new Error(`unclosed SVG element: ${stack.at(-1).name}`);
+  return root.children;
+}
+
+function parseSvg(source) {
+  const nodes = parseNodes(source.trim());
+  if (nodes.length !== 1 || nodes[0].name !== 'svg') throw new Error('SVG document must have one svg root');
+  const root = nodes[0];
+  return { viewBox: new Map(root.attrs).get('viewBox') ?? '0 0 24 24', rootAttrs: root.attrs, children: root.children };
+}
+
+function serializeNodes(nodes) {
+  return nodes.map((node) => Object.hasOwn(node, 'text') ? escapeXml(node.text) :
+    `<${node.name}${node.attrs.map(([name, value]) => ` ${name}="${escapeXml(value)}"`).join('')}${node.children.length ? `>${serializeNodes(node.children)}</${node.name}>` : ' />'}`).join('');
+}
+
+const ROOT_METADATA = new Set(['viewBox', 'width', 'height', 'xmlns', 'xmlns:xlink', 'version']);
+function rootPaintAttributes(rootAttrs, strategy) {
+  const attrs = new Map(rootAttrs.filter(([name]) => !ROOT_METADATA.has(name)));
+  if (strategy === 'outline') {
+    if (!attrs.has('stroke')) attrs.set('stroke', 'currentColor');
+    if (!attrs.has('fill')) attrs.set('fill', 'none');
+    if (!attrs.has('stroke-width')) attrs.set('stroke-width', '2');
+  } else if (strategy === 'solid' && !attrs.has('fill')) attrs.set('fill', 'currentColor');
+  return attrs;
+}
+
+function normalizePaintChildren(children, strategy, rootAttrs = []) {
+  const graphic = new Set(['path', 'circle', 'ellipse', 'line', 'polyline', 'polygon', 'rect', 'text', 'use', 'image']);
+  const rootWidth = new Map(rootAttrs).get('stroke-width') ?? '2';
+  return children.map((node) => {
+    if (Object.hasOwn(node, 'text')) return node;
+    const attrs = node.attrs.flatMap(([name, value]) => {
+      if (!graphic.has(node.name)) return [[name, value]];
+      if (strategy === 'outline' && name === 'stroke-width' && value === '2' && rootWidth === '2') return [];
+      const tint = /^(?:black|#000(?:000)?)$/i.test(value);
+      return [[name, tint && ((strategy === 'outline' && name === 'stroke') || (strategy === 'solid' && name === 'fill')) ? 'currentColor' : value]];
+    });
+    const inherited = new Map(rootAttrs);
+    const localWidth = new Map(node.attrs).get('stroke-width');
+    if (localWidth !== undefined) inherited.set('stroke-width', localWidth);
+    return { ...node, attrs, children: normalizePaintChildren(node.children, strategy, [...inherited]) };
+  });
+}
+
+function prepareSvg(source, strategy) {
+  const model = parseSvg(source);
+  // Approved Figma artboard pair. Never remove a lone/other painted rect.
+  const [first, second] = model.children;
+  if (first?.name === 'rect' && second?.name === 'rect' && !first.children.length && !second.children.length) {
+    const a = new Map(first.attrs), b = new Map(second.attrs);
+    if (a.size === 3 && a.get('width') === '24' && a.get('height') === '24' && a.get('fill') === '#1E1E1E' &&
+        b.size === 4 && /^\d+$/.test(b.get('width') ?? '') && /^\d+$/.test(b.get('height') ?? '') &&
+        /^translate\(-?\d+(?:\.\d+)? -?\d+(?:\.\d+)?\)$/.test(b.get('transform') ?? '') && b.get('fill') === 'white') model.children = model.children.slice(2);
+  }
+  model.children = normalizePaintChildren(model.children, strategy, model.rootAttrs);
+  return model;
+}
+
+module.exports = { decodeXml, escapeXml, parseAttributes, parseNodes, parseSvg, prepareSvg, serializeNodes, rootPaintAttributes };

package/dist/generator/svg-model.d.ts

@@ -0,0 +1,16 @@
+export type SvgNode = {
+    readonly name: string;
+    readonly attrs: readonly [string, string][];
+    readonly children: readonly SvgNode[];
+    readonly text?: never;
+} | {
+    readonly text: string;
+};
+interface SvgModel {
+    viewBox: string;
+    rootAttrs: readonly [string, string][];
+    children: readonly SvgNode[];
+}
+export declare const prepareSvg: (source: string, strategy: string) => SvgModel;
+export declare const rootPaintAttributes: (attrs: readonly [string, string][], strategy: string) => Map<string, string>;
+export {};

package/dist/generator/svg-model.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+const shared = createRequire(import.meta.url)("./shared/svg-model.cjs");
+export const prepareSvg = shared.prepareSvg;
+export const rootPaintAttributes = shared.rootPaintAttributes;

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

@@ -10,6 +10,8 @@ export interface ResolvedTheme {
     readonly group: CatalogStyleGroup;
     readonly variant?: ResourceVariant;
 }
+/** Exact availability check: catalog `variants` is authoritative when present. */
+export declare function isVariantAvailable(group: CatalogStyleGroup, resourceVariantId: string): boolean;
 export declare function resolveThemes(config: MoeiconsConfigFile, sourceCatalog?: IconCatalog): {
     readonly ok: true;
     readonly themes: ResolvedTheme[];

package/dist/generator/theme-resolve.js

@@ -1,6 +1,15 @@
 import { catalog, findCatalogStyleGroup } from "../catalog/catalog.js";
-import { assetRelativePath, resolveResourceVariant, } from "../core/resource-variant.js";
+import { assetRelativePath, buildResourceVariantId, DEFAULT_BITMAP_FORMAT, DEFAULT_BITMAP_SIZE, resolveResourceVariant, } from "../core/resource-variant.js";
 import { toLibraryExportName, toProxyName } from "../core/icon-names.js";
+/** Exact availability check: catalog `variants` is authoritative when present. */
+export function isVariantAvailable(group, resourceVariantId) {
+    if (group.variants && group.variants.length > 0)
+        return group.variants.includes(resourceVariantId);
+    const parts = resourceVariantId.split("-");
+    const format = parts[parts.length - 1];
+    const imageSize = Number(parts[parts.length - 2]);
+    return group.formats.includes(format) && group.imageSizes.includes(imageSize);
+}
 export function resolveThemes(config, sourceCatalog = catalog) {
     const errors = [];
     const themes = [];
@@ -12,15 +21,25 @@ export function resolveThemes(config, sourceCatalog = catalog) {
         }
         if (group.type === "bitmap") {
             try {
-                const variant = resolveResourceVariant(entry.styleGroup, {
-                    ...(entry.format !== undefined ? { format: entry.format } : {}),
-                    ...(entry.imageSize !== undefined ? { imageSize: entry.imageSize } : {}),
-                });
-                if (!group.formats.includes(variant.format)) {
-                    errors.push(`format ${variant.format} is unavailable for ${group.id}`);
+                let variant;
+                if (entry.format === undefined && entry.imageSize === undefined) {
+                    // B6: the default is only usable when the group truly declares it.
+                    const defaultId = buildResourceVariantId(group.id, DEFAULT_BITMAP_FORMAT, DEFAULT_BITMAP_SIZE);
+                    if (!isVariantAvailable(group, defaultId)) {
+                        errors.push(`bitmap group "${group.id}" does not include the default ${DEFAULT_BITMAP_FORMAT}/${String(DEFAULT_BITMAP_SIZE)} variant; set format and imageSize explicitly`);
+                        continue;
+                    }
+                    variant = resolveResourceVariant(group.id);
+                }
+                else {
+                    variant = resolveResourceVariant(group.id, {
+                        ...(entry.format !== undefined ? { format: entry.format } : {}),
+                        ...(entry.imageSize !== undefined ? { imageSize: entry.imageSize } : {}),
+                    });
                 }
-                if (!group.imageSizes.includes(variant.imageSize)) {
-                    errors.push(`imageSize ${String(variant.imageSize)} is unavailable for ${group.id}`);
+                if (!isVariantAvailable(group, variant.resourceVariantId)) {
+                    errors.push(`variant ${variant.resourceVariantId} is unavailable for ${group.id}`);
+                    continue;
                 }
                 themes.push({ theme, entry, kind: "bitmap", group, variant });
             }
@@ -49,24 +68,30 @@ export function relativeAssetImportFromIcons(variant, iconId) {
 export function reactBitmapWrapperSource(iconId, wrapperName, variant, themeClassName) {
     const assetImport = relativeAssetImportFromIcons(variant, iconId);
     const defaultClass = themeClassName ? JSON.stringify(themeClassName) : "undefined";
-    return `import type { IconProps } from "../types";
+    return `import * as React from "react";
+import type { IconProps } from "../types";
 import { cn } from "../cn";
 import assetUrl from "${assetImport}";
 
-export function ${wrapperName}(props: IconProps) {
-  const { className, size, "aria-label": ariaLabel, strokeWidth: _strokeWidth, ...rest } = props;
-  const sizeClass = typeof size === "number" ? \`w-[\${size}px] h-[\${size}px]\` : undefined;
+export const ${wrapperName} = /* @__PURE__ */ React.forwardRef<HTMLImageElement, IconProps>((props, ref) => {
+  const { className, size, alt, "aria-label": ariaLabel, strokeWidth: _strokeWidth, ...rest } = props;
+  const label = ariaLabel ?? alt ?? (typeof rest.title === "string" ? rest.title : undefined);
+  const named = Boolean(label || rest["aria-labelledby"]);
+  const imageSource = typeof assetUrl === "string" ? assetUrl : (assetUrl as { src: string }).src;
   return (
     <img
-      src={assetUrl}
-      alt={ariaLabel ?? ""}
-      aria-hidden={ariaLabel ? undefined : true}
+      ref={ref}
+      src={imageSource}
+      width={size ?? 24}
+      height={size ?? 24}
+      alt={label ?? ""}
+      aria-hidden={named ? undefined : true}
       draggable={false}
-      className={cn("moe-icon", ${defaultClass}, sizeClass, className)}
+      className={cn("moe-icon", ${defaultClass}, className)}
       {...rest}
     />
   );
-}
+});
 `;
 }
 export function vueBitmapWrapperSource(iconId, wrapperName, variant, themeClassName) {
@@ -76,21 +101,27 @@ export function vueBitmapWrapperSource(iconId, wrapperName, variant, themeClassN
 import { cn } from "../cn";
 import assetUrl from "${assetImport}";
 
-export const ${wrapperName} = defineComponent({
+export const ${wrapperName} = /* @__PURE__ */ defineComponent({
   name: "${wrapperName}",
+  inheritAttrs: false,
   setup(_props, { attrs }) {
     return () => {
-      const className = typeof attrs.class === "string" ? attrs.class : undefined;
       const size = typeof attrs.size === "number" ? attrs.size : undefined;
       const ariaLabel = typeof attrs["aria-label"] === "string" ? attrs["aria-label"] : undefined;
-      const sizeClass = typeof size === "number" ? \`w-[\${size}px] h-[\${size}px]\` : undefined;
+      const alt = typeof attrs.alt === "string" ? attrs.alt : undefined;
+      const label = ariaLabel ?? alt ?? (typeof attrs.title === "string" ? attrs.title : undefined);
+      const named = Boolean(label || attrs["aria-labelledby"]);
+      const imageAttrs = { ...attrs };
+      delete imageAttrs.size;
       return h("img", {
-        ...attrs,
+        ...imageAttrs,
         src: assetUrl,
-        alt: ariaLabel ?? "",
-        "aria-hidden": ariaLabel ? undefined : true,
-        draggable: false,
-        class: cn("moe-icon", ${defaultClass}, sizeClass, className),
+        width: attrs.width ?? size ?? 24,
+        height: attrs.height ?? size ?? 24,
+        alt: label ?? "",
+        "aria-hidden": attrs["aria-hidden"] ?? (named ? undefined : true),
+        draggable: attrs.draggable ?? false,
+        class: cn("moe-icon", ${defaultClass}, attrs.class as Parameters<typeof cn>[number]),
       });
     };
   },

package/dist/mcp/server.d.ts

@@ -1,32 +1,11 @@
-/**
- * Minimal MCP (Model Context Protocol) stdio server. Registers only v1 tools:
- * list_icon_groups, get_account, install_icon_group. Protocol data goes only
- * to stdout; logs go to stderr. Graceful shutdown on SIGINT/SIGTERM.
- */
-interface McpRequest {
-    readonly jsonrpc: "2.0";
-    readonly id: number | string;
-    readonly method: string;
-    readonly params?: Record<string, unknown>;
-}
-interface McpResponse {
-    readonly jsonrpc: "2.0";
-    readonly id: number | string;
-    readonly result?: unknown;
-    readonly error?: {
-        code: number;
-        message: string;
-    };
+export interface McpTool {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Record<string, unknown>;
 }
 export interface McpServices {
-    readonly listIconGroups: () => Promise<readonly {
-        id: string;
-        displayName: string;
-    }[]>;
-    readonly getAccount: () => Promise<{
-        accountId: string;
-        tier: string;
-    } | undefined>;
+    readonly listIconGroups: () => Promise<unknown>;
+    readonly getAccount: () => Promise<unknown>;
     readonly installIconGroup: (args: {
         groupId: string;
         projectPath: string;
@@ -34,24 +13,32 @@ export interface McpServices {
         ok: boolean;
         message: string;
     }>;
+    readonly tools?: readonly McpTool[];
+    readonly callTool?: (name: string, args: Record<string, unknown>) => Promise<unknown>;
 }
 export interface McpDeps {
     readonly services: McpServices;
     readonly stdout: (text: string) => void;
     readonly stderr: (text: string) => void;
     readonly signal?: AbortSignal;
+    readonly projectRoot?: string;
+}
+interface Response {
+    jsonrpc: "2.0";
+    id: number | string | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+export declare class McpArgumentError extends Error {
 }
-/**
- * Create an MCP server bound to injected streams. Returns a dispatcher that
- * handles one decoded JSON-RPC message.
- */
+export declare const isRecord: (v: unknown) => v is Record<string, unknown>;
+export declare function safeMcpValue(value: unknown, projectRoot?: string): unknown;
 export declare function createMcpServer(deps: McpDeps): {
-    handle: (message: McpRequest) => Promise<McpResponse | undefined>;
+    handle: (value: unknown) => Promise<Response | undefined>;
 };
-/**
- * Read JSON-RPC messages from an async iterable of lines and write responses to
- * stdout. Used by the stdio transport.
- */
 export declare function runMcpStdio(deps: McpDeps & {
     lines: AsyncIterable<string>;
 }): Promise<void>;