@grida/refig 0.0.0

package/dist/cli.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+import {
+  FigmaDocument,
+  FigmaRenderer,
+  collectExportsFromDocument,
+  exportSettingToRenderOptions,
+  figFileToRestLikeDocument,
+  iofigma
+} from "./chunk-DAHUXARL.mjs";
+
+// cli.ts
+import {
+  readFileSync,
+  readdirSync,
+  mkdirSync,
+  writeFileSync,
+  existsSync,
+  statSync
+} from "fs";
+import path from "path";
+import { program } from "commander";
+var FORMAT_SET = /* @__PURE__ */ new Set(["png", "jpeg", "webp", "pdf", "svg"]);
+var DOCUMENT_JSON = "document.json";
+var IMAGES_SUBDIR = "images";
+function formatFromOutFile(outPath) {
+  const ext = path.extname(outPath).replace(/^\./, "").toLowerCase();
+  if (ext === "jpg") return "jpeg";
+  return FORMAT_SET.has(ext) ? ext : "png";
+}
+var EXT_BY_FORMAT = {
+  png: "png",
+  jpeg: "jpeg",
+  jpg: "jpeg",
+  svg: "svg",
+  pdf: "pdf"
+};
+function sanitizeForFilename(s) {
+  return String(s).replace(/[:/\\]/g, "_").replace(/\s+/g, "_") || "_";
+}
+function resolveInput(inputPath, explicitImagesDir) {
+  const resolved = path.resolve(inputPath);
+  const stat = statSync(resolved);
+  if (stat.isDirectory()) {
+    const documentPath = path.join(resolved, DOCUMENT_JSON);
+    if (!existsSync(documentPath)) {
+      throw new Error(
+        `Input directory must contain ${DOCUMENT_JSON}; not found: ${documentPath}`
+      );
+    }
+    const imagesDir = path.join(resolved, IMAGES_SUBDIR);
+    const useImagesDir = existsSync(imagesDir) && statSync(imagesDir).isDirectory() ? imagesDir : void 0;
+    return {
+      documentPath,
+      imagesDir: explicitImagesDir ? path.resolve(explicitImagesDir) : useImagesDir,
+      isRestJson: true
+    };
+  }
+  return {
+    documentPath: resolved,
+    imagesDir: explicitImagesDir ? path.resolve(explicitImagesDir) : void 0,
+    isRestJson: resolved.toLowerCase().endsWith(".json")
+  };
+}
+function readImagesFromDir(dirPath) {
+  const out = {};
+  for (const file of readdirSync(dirPath)) {
+    const fullPath = path.join(dirPath, file);
+    if (!statSync(fullPath).isFile()) continue;
+    const ref = path.basename(file).replace(/\.[^.]+$/, "");
+    if (!ref) continue;
+    const buf = readFileSync(fullPath);
+    out[ref] = new Uint8Array(buf);
+  }
+  return out;
+}
+function exportAllOutputBasename(nodeId, suffix, format) {
+  const ext = EXT_BY_FORMAT[format] ?? "png";
+  const safeId = sanitizeForFilename(nodeId);
+  const safeSuffix = sanitizeForFilename(suffix);
+  const name = safeSuffix ? `${safeId}_${safeSuffix}` : safeId;
+  return `${name}.${ext}`;
+}
+async function runExportAll(documentPath, outDir, imagesDir) {
+  const isFig = documentPath.toLowerCase().endsWith(".fig");
+  let document;
+  let items;
+  let rendererOptions = {};
+  if (isFig) {
+    const bytes = new Uint8Array(readFileSync(documentPath));
+    const figFile = iofigma.kiwi.parseFile(bytes);
+    const restDoc = figFileToRestLikeDocument(figFile);
+    items = collectExportsFromDocument(restDoc);
+    document = new FigmaDocument(bytes);
+    const imagesMap = iofigma.kiwi.extractImages(figFile.zip_files);
+    const images = {};
+    imagesMap.forEach((imgBytes, ref) => {
+      images[ref] = imgBytes;
+    });
+    if (Object.keys(images).length > 0) {
+      rendererOptions = { images };
+    }
+  } else {
+    const json = JSON.parse(readFileSync(documentPath, "utf8"));
+    document = new FigmaDocument(json);
+    items = collectExportsFromDocument(
+      document.payload
+    );
+    if (imagesDir) {
+      rendererOptions = { images: readImagesFromDir(imagesDir) };
+    }
+  }
+  if (items.length === 0) {
+    process.stdout.write("No nodes with export settings found.\n");
+    return;
+  }
+  const renderer = new FigmaRenderer(document, rendererOptions);
+  try {
+    for (const { nodeId: nid, node, setting } of items) {
+      const options = exportSettingToRenderOptions(node, setting);
+      const result = await renderer.render(nid, options);
+      const basename = exportAllOutputBasename(
+        nid,
+        setting.suffix,
+        result.format
+      );
+      const filePath = path.join(outDir, basename);
+      writeFileSync(filePath, Buffer.from(result.data));
+      process.stdout.write(
+        `wrote ${filePath} (${result.mimeType}, ${result.data.byteLength} bytes)
+`
+      );
+    }
+    process.stdout.write(`Exported ${items.length} file(s) to ${outDir}
+`);
+  } finally {
+    renderer.dispose();
+  }
+}
+async function runSingleNode(documentPath, nodeId, outPath, opts) {
+  const format = (opts.format ?? formatFromOutFile(outPath)).toLowerCase();
+  if (!FORMAT_SET.has(format)) {
+    throw new Error(`Unsupported --format "${format}"`);
+  }
+  const isJson = documentPath.toLowerCase().endsWith(".json");
+  const document = isJson ? new FigmaDocument(JSON.parse(readFileSync(documentPath, "utf8"))) : new FigmaDocument(new Uint8Array(readFileSync(documentPath)));
+  const rendererOptions = isJson && opts.imagesDir ? { images: readImagesFromDir(opts.imagesDir) } : {};
+  const renderer = new FigmaRenderer(document, rendererOptions);
+  try {
+    const result = await renderer.render(nodeId, {
+      format,
+      width: opts.width,
+      height: opts.height,
+      scale: opts.scale
+    });
+    mkdirSync(path.dirname(outPath), { recursive: true });
+    writeFileSync(outPath, Buffer.from(result.data));
+    process.stdout.write(
+      `wrote ${outPath} (${result.mimeType}, ${result.data.byteLength} bytes)
+`
+    );
+  } finally {
+    renderer.dispose();
+  }
+}
+async function main() {
+  program.name("refig").description(
+    "Headless Figma renderer \u2014 render .fig and REST API JSON to PNG/JPEG/WebP/PDF/SVG"
+  ).argument(
+    "<input>",
+    "Path to .fig, JSON file (REST API response), or directory containing document.json (and optionally images/)"
+  ).requiredOption(
+    "--out <path>",
+    "Output file path (single node) or output directory (--export-all)"
+  ).option(
+    "--images <dir>",
+    "Directory of image files for REST API document (optional; not used if <input> is a dir with images/)"
+  ).option(
+    "--node <id>",
+    "Figma node ID to render (required unless --export-all)"
+  ).option(
+    "--export-all",
+    "Export every node that has exportSettings (REST JSON only)"
+  ).option(
+    "--format <fmt>",
+    "png | jpeg | webp | pdf | svg (single-node only; default: from --out extension)"
+  ).option("--width <px>", "Viewport width (single-node only)", "1024").option("--height <px>", "Viewport height (single-node only)", "1024").option("--scale <n>", "Raster scale factor (single-node only)", "1").action(
+    async (input, options) => {
+      const outPath = String(options.out ?? "").trim();
+      const exportAll = options.exportAll === true;
+      const nodeId = String(options.node ?? "").trim();
+      const explicitImagesDir = typeof options.images === "string" ? options.images : void 0;
+      if (!outPath) {
+        program.error("--out is required");
+      }
+      const { documentPath, imagesDir, isRestJson } = resolveInput(
+        input.trim(),
+        explicitImagesDir
+      );
+      if (exportAll) {
+        if (nodeId) {
+          program.error("--node must not be used with --export-all");
+        }
+        const outDir = path.resolve(outPath);
+        if (existsSync(outDir)) {
+          const stat = statSync(outDir);
+          if (!stat.isDirectory()) {
+            program.error(
+              "--out must be a directory when using --export-all"
+            );
+          }
+        } else {
+          mkdirSync(outDir, { recursive: true });
+        }
+        await runExportAll(documentPath, outDir, imagesDir);
+        return;
+      }
+      if (!nodeId) {
+        program.error("--node is required (or use --export-all)");
+      }
+      const width = Number(options.width ?? 1024);
+      const height = Number(options.height ?? 1024);
+      const scale = Number(options.scale ?? 1);
+      await runSingleNode(documentPath, nodeId, path.resolve(outPath), {
+        format: typeof options.format === "string" ? options.format : void 0,
+        width,
+        height,
+        scale,
+        imagesDir
+      });
+    }
+  );
+  await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+});

package/dist/index.d.mts

@@ -0,0 +1,17 @@
+import { FigmaRenderer } from './browser.mjs';
+export { ExportItem, FigmaDocument, RefigRenderFormat, RefigRenderOptions, RefigRenderResult, RefigRendererOptions, collectExportsFromDocument, exportSettingToRenderOptions, resolveMimeType } from './browser.mjs';
+import '@figma/rest-api-spec';
+
+/**
+ * @grida/refig — Node.js entrypoint
+ *
+ * Re-exports the full core API and adds Node-specific helpers (file I/O).
+ */
+
+declare module "./lib" {
+    namespace FigmaDocument {
+        function fromFile(filePath: string): FigmaDocument;
+    }
+}
+
+export { FigmaRenderer, FigmaRenderer as default };

package/dist/index.mjs

@@ -0,0 +1,30 @@
+import {
+  FigmaDocument,
+  FigmaRenderer,
+  collectExportsFromDocument,
+  exportSettingToRenderOptions,
+  resolveMimeType
+} from "./chunk-DAHUXARL.mjs";
+
+// index.ts
+import { readFileSync } from "fs";
+FigmaDocument.fromFile = function fromFile(filePath) {
+  const normalized = filePath.trim();
+  if (!normalized) {
+    throw new Error("FigmaDocument.fromFile: path must be non-empty");
+  }
+  if (normalized.toLowerCase().endsWith(".json")) {
+    const text = readFileSync(normalized, "utf-8");
+    return new FigmaDocument(JSON.parse(text));
+  }
+  return new FigmaDocument(new Uint8Array(readFileSync(normalized)));
+};
+var index_default = FigmaRenderer;
+export {
+  FigmaDocument,
+  FigmaRenderer,
+  collectExportsFromDocument,
+  index_default as default,
+  exportSettingToRenderOptions,
+  resolveMimeType
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@grida/refig",
+  "version": "0.0.0",
+  "private": false,
+  "description": "Headless Figma renderer — render .fig and REST API JSON to PNG/JPEG/WebP/PDF/SVG",
+  "keywords": [
+    "canvas",
+    "cli",
+    "fig",
+    "fig-file",
+    "figma",
+    "figma-renderer",
+    "grida",
+    "headless",
+    "jpeg",
+    "pdf",
+    "png",
+    "refig",
+    "skia",
+    "svg",
+    "wasm",
+    "webp"
+  ],
+  "homepage": "https://github.com/gridaco/grida/tree/main/packages/grida-canvas-sdk-render-figma",
+  "bugs": "https://github.com/gridaco/grida/issues",
+  "license": "MIT",
+  "author": "softmarshmallow",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gridaco/grida.git",
+    "directory": "packages/grida-canvas-sdk-render-figma"
+  },
+  "bin": {
+    "refig": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.mts",
+      "import": "./dist/browser.mjs",
+      "default": "./dist/browser.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@grida/canvas-wasm": "0.90.0-canary.6",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@figma/rest-api-spec": "0.35.0",
+    "fflate": "^0.8.2",
+    "tsup": "^8.5.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}