@wire-dsl/exporters 0.0.2

package/LICENSE

@@ -0,0 +1,36 @@
+MIT License
+
+Copyright (c) 2026 WireDSL Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+## Third-Party Components & Assets
+
+### Feather Icons
+
+This project includes icons from Feather Icons (https://feathericons.com), created by Cole Bemis and contributors.
+
+- **License**: MIT License
+- **Repository**: https://github.com/feathericons/feather
+- **Location in project**: `packages/core/src/renderer/icons/`
+- **Full details**: See `packages/core/src/renderer/icons/ICONS-LICENSE.md`
+
+Feather Icons are used under the terms of the MIT License, which is fully compatible with this project's MIT License.

package/README.md

@@ -0,0 +1,77 @@
+# @wire-dsl/exporters
+
+Node.js exporters for Wire-DSL. Provides file I/O functions to export wireframes as SVG, PNG, and PDF files. **Node.js only - depends on sharp, pdfkit.**
+
+## Installation
+
+```bash
+npm install @wire-dsl/exporters @wire-dsl/engine
+```
+
+## Quick Start
+
+```typescript
+import { exportSVG, exportPNG, exportMultipagePDF } from '@wire-dsl/exporters';
+import { parseWire, generateIR, computeLayout } from '@wire-dsl/engine';
+
+// Parse and layout your wireframe
+const ast = parseWire(wireCode);
+const ir = generateIR(ast);
+const layout = computeLayout(ir);
+
+// Export to file
+await exportSVG(ir, layout, 'output.svg');
+await exportPNG(ir, layout, 'output.png');
+await exportMultipagePDF(ir, layout, 'output.pdf');
+```
+
+## Functions
+
+### exportSVG(ir, layout, outputPath)
+Export wireframe as SVG file.
+
+```typescript
+import { exportSVG } from '@wire-dsl/exporters';
+
+await exportSVG(ir, layout, 'wireframe.svg');
+// → wireframe.svg (scalable vector)
+```
+
+### exportPNG(ir, layout, outputPath)
+Export wireframe as PNG image (uses sharp).
+
+```typescript
+import { exportPNG } from '@wire-dsl/exporters';
+
+await exportPNG(ir, layout, 'wireframe.png');
+// → wireframe.png (1920x1080 PNG)
+```
+
+### exportMultipagePDF(ir, layout, outputPath)
+Export all screens as multipage PDF document (uses pdfkit).
+
+```typescript
+import { exportMultipagePDF } from '@wire-dsl/exporters';
+
+await exportMultipagePDF(ir, layout, 'wireframe.pdf');
+// → wireframe.pdf (one page per screen)
+```
+
+## Dependencies
+
+- `@wire-dsl/engine` - Core parsing and layout
+- `pdfkit` - PDF file generation
+- `sharp` - PNG image processing (native bindings)
+- `svg-to-pdfkit` - SVG to PDF rendering
+
+## Configuration
+
+All export functions use sensible defaults:
+
+- **SVG**: Preserve colors, no optimization
+- **PNG**: 1920x1080, 72 DPI (web standard)
+- **PDF**: A4 size, embedded fonts, multipage
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,153 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  exportMultipagePDF: () => exportMultipagePDF,
+  exportPNG: () => exportPNG,
+  exportSVG: () => exportSVG,
+  extractSVGDimensions: () => extractSVGDimensions,
+  hexToRgba: () => hexToRgba,
+  preprocessSVGColors: () => preprocessSVGColors,
+  version: () => version
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/svg.ts
+var import_promises = require("fs/promises");
+async function exportSVG(svg, outputPath) {
+  const path2 = require("path");
+  const outputDir = path2.dirname(outputPath);
+  await (0, import_promises.mkdir)(outputDir, { recursive: true }).catch(() => {
+  });
+  await (0, import_promises.writeFile)(outputPath, svg, "utf8");
+}
+
+// src/png.ts
+var import_sharp = __toESM(require("sharp"), 1);
+async function exportPNG(svg, outputPath, width, height) {
+  const buffer = Buffer.from(svg);
+  let operation = (0, import_sharp.default)(buffer);
+  if (width && height) {
+    operation = operation.resize(width, height);
+  }
+  await operation.png().toFile(outputPath);
+}
+
+// src/pdf.ts
+var import_promises2 = require("fs/promises");
+var import_fs = require("fs");
+var import_path = __toESM(require("path"), 1);
+var import_pdfkit = __toESM(require("pdfkit"), 1);
+var import_svg_to_pdfkit = __toESM(require("svg-to-pdfkit"), 1);
+
+// src/helpers.ts
+function extractSVGDimensions(svgString) {
+  const widthMatch = svgString.match(/width="(\d+(?:\.\d+)?)/);
+  const heightMatch = svgString.match(/height="(\d+(?:\.\d+)?)/);
+  return {
+    width: widthMatch ? parseFloat(widthMatch[1]) : 800,
+    height: heightMatch ? parseFloat(heightMatch[1]) : 600
+  };
+}
+function hexToRgba(hex) {
+  if (hex.length === 9) {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    const a = parseInt(hex.slice(7, 9), 16) / 255;
+    return `rgba(${r},${g},${b},${a.toFixed(2)})`;
+  }
+  return hex;
+}
+function preprocessSVGColors(svg) {
+  return svg.replace(/#[0-9A-Fa-f]{8}\b/g, (match) => hexToRgba(match));
+}
+
+// src/pdf.ts
+async function exportMultipagePDF(svgs, outputPath) {
+  return new Promise(async (resolve, reject) => {
+    const outputDir = import_path.default.dirname(outputPath);
+    try {
+      await (0, import_promises2.mkdir)(outputDir, { recursive: true });
+    } catch (error) {
+    }
+    const pagesWithActualDimensions = svgs.map((page) => {
+      const processedSvg = preprocessSVGColors(page.svg);
+      const actualDims = extractSVGDimensions(processedSvg);
+      return {
+        ...page,
+        svg: processedSvg,
+        actualWidth: actualDims.width,
+        actualHeight: actualDims.height
+      };
+    });
+    const firstPage = pagesWithActualDimensions[0];
+    const doc = new import_pdfkit.default({
+      size: [firstPage.actualWidth, firstPage.actualHeight],
+      margin: 0
+    });
+    const stream = (0, import_fs.createWriteStream)(outputPath);
+    doc.pipe(stream);
+    pagesWithActualDimensions.forEach((page, index) => {
+      if (index > 0) {
+        doc.addPage({
+          size: [page.actualWidth, page.actualHeight],
+          margin: 0
+        });
+      }
+      try {
+        (0, import_svg_to_pdfkit.default)(doc, page.svg, 0, 0, {
+          width: page.actualWidth,
+          height: page.actualHeight,
+          assumePt: true
+        });
+      } catch (error) {
+        console.error(`Error rendering page ${page.name}:`, error);
+      }
+    });
+    doc.end();
+    stream.on("finish", () => resolve());
+    stream.on("error", (err) => reject(err));
+  });
+}
+
+// src/index.ts
+var version = "0.1.6";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exportMultipagePDF,
+  exportPNG,
+  exportSVG,
+  extractSVGDimensions,
+  hexToRgba,
+  preprocessSVGColors,
+  version
+});

package/dist/index.d.cts

@@ -0,0 +1,54 @@
+/**
+ * Save SVG string to file
+ * @param svg SVG string content
+ * @param outputPath Path where to save the file
+ */
+declare function exportSVG(svg: string, outputPath: string): Promise<void>;
+
+/**
+ * Export SVG to PNG using sharp
+ * @param svg SVG string content
+ * @param outputPath Path where to save the PNG file
+ * @param width Optional image width (defaults from SVG if not provided)
+ * @param height Optional image height (defaults from SVG if not provided)
+ */
+declare function exportPNG(svg: string, outputPath: string, width?: number, height?: number): Promise<void>;
+
+/**
+ * Export multiple SVGs as a single multipage PDF
+ * Each SVG becomes a page in the PDF with its own dimensions
+ * @param svgs Array of SVG objects with svg content, width, height, and name
+ * @param outputPath Path where to save the PDF file
+ */
+declare function exportMultipagePDF(svgs: Array<{
+    svg: string;
+    width: number;
+    height: number;
+    name: string;
+}>, outputPath: string): Promise<void>;
+
+/**
+ * Helper functions for SVG and PDF processing
+ */
+/**
+ * Extract actual width and height from rendered SVG string
+ * The SVG renderer may produce dynamic heights, so we extract actual dimensions
+ */
+declare function extractSVGDimensions(svgString: string): {
+    width: number;
+    height: number;
+};
+/**
+ * Convert hex color with opacity (e.g., #3B82F615) to rgba format
+ * This helps svg-to-pdfkit render colors with transparency correctly
+ */
+declare function hexToRgba(hex: string): string;
+/**
+ * Preprocess SVG to convert hex colors with opacity to rgba format
+ * This ensures svg-to-pdfkit renders them correctly
+ */
+declare function preprocessSVGColors(svg: string): string;
+
+declare const version = "0.1.6";
+
+export { exportMultipagePDF, exportPNG, exportSVG, extractSVGDimensions, hexToRgba, preprocessSVGColors, version };

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Save SVG string to file
+ * @param svg SVG string content
+ * @param outputPath Path where to save the file
+ */
+declare function exportSVG(svg: string, outputPath: string): Promise<void>;
+
+/**
+ * Export SVG to PNG using sharp
+ * @param svg SVG string content
+ * @param outputPath Path where to save the PNG file
+ * @param width Optional image width (defaults from SVG if not provided)
+ * @param height Optional image height (defaults from SVG if not provided)
+ */
+declare function exportPNG(svg: string, outputPath: string, width?: number, height?: number): Promise<void>;
+
+/**
+ * Export multiple SVGs as a single multipage PDF
+ * Each SVG becomes a page in the PDF with its own dimensions
+ * @param svgs Array of SVG objects with svg content, width, height, and name
+ * @param outputPath Path where to save the PDF file
+ */
+declare function exportMultipagePDF(svgs: Array<{
+    svg: string;
+    width: number;
+    height: number;
+    name: string;
+}>, outputPath: string): Promise<void>;
+
+/**
+ * Helper functions for SVG and PDF processing
+ */
+/**
+ * Extract actual width and height from rendered SVG string
+ * The SVG renderer may produce dynamic heights, so we extract actual dimensions
+ */
+declare function extractSVGDimensions(svgString: string): {
+    width: number;
+    height: number;
+};
+/**
+ * Convert hex color with opacity (e.g., #3B82F615) to rgba format
+ * This helps svg-to-pdfkit render colors with transparency correctly
+ */
+declare function hexToRgba(hex: string): string;
+/**
+ * Preprocess SVG to convert hex colors with opacity to rgba format
+ * This ensures svg-to-pdfkit renders them correctly
+ */
+declare function preprocessSVGColors(svg: string): string;
+
+declare const version = "0.1.6";
+
+export { exportMultipagePDF, exportPNG, exportSVG, extractSVGDimensions, hexToRgba, preprocessSVGColors, version };

package/dist/index.js

@@ -0,0 +1,117 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/svg.ts
+import { writeFile, mkdir } from "fs/promises";
+async function exportSVG(svg, outputPath) {
+  const path2 = __require("path");
+  const outputDir = path2.dirname(outputPath);
+  await mkdir(outputDir, { recursive: true }).catch(() => {
+  });
+  await writeFile(outputPath, svg, "utf8");
+}
+
+// src/png.ts
+import sharp from "sharp";
+async function exportPNG(svg, outputPath, width, height) {
+  const buffer = Buffer.from(svg);
+  let operation = sharp(buffer);
+  if (width && height) {
+    operation = operation.resize(width, height);
+  }
+  await operation.png().toFile(outputPath);
+}
+
+// src/pdf.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { createWriteStream } from "fs";
+import path from "path";
+import PDFDocument from "pdfkit";
+import SVGtoPDF from "svg-to-pdfkit";
+
+// src/helpers.ts
+function extractSVGDimensions(svgString) {
+  const widthMatch = svgString.match(/width="(\d+(?:\.\d+)?)/);
+  const heightMatch = svgString.match(/height="(\d+(?:\.\d+)?)/);
+  return {
+    width: widthMatch ? parseFloat(widthMatch[1]) : 800,
+    height: heightMatch ? parseFloat(heightMatch[1]) : 600
+  };
+}
+function hexToRgba(hex) {
+  if (hex.length === 9) {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    const a = parseInt(hex.slice(7, 9), 16) / 255;
+    return `rgba(${r},${g},${b},${a.toFixed(2)})`;
+  }
+  return hex;
+}
+function preprocessSVGColors(svg) {
+  return svg.replace(/#[0-9A-Fa-f]{8}\b/g, (match) => hexToRgba(match));
+}
+
+// src/pdf.ts
+async function exportMultipagePDF(svgs, outputPath) {
+  return new Promise(async (resolve, reject) => {
+    const outputDir = path.dirname(outputPath);
+    try {
+      await mkdir2(outputDir, { recursive: true });
+    } catch (error) {
+    }
+    const pagesWithActualDimensions = svgs.map((page) => {
+      const processedSvg = preprocessSVGColors(page.svg);
+      const actualDims = extractSVGDimensions(processedSvg);
+      return {
+        ...page,
+        svg: processedSvg,
+        actualWidth: actualDims.width,
+        actualHeight: actualDims.height
+      };
+    });
+    const firstPage = pagesWithActualDimensions[0];
+    const doc = new PDFDocument({
+      size: [firstPage.actualWidth, firstPage.actualHeight],
+      margin: 0
+    });
+    const stream = createWriteStream(outputPath);
+    doc.pipe(stream);
+    pagesWithActualDimensions.forEach((page, index) => {
+      if (index > 0) {
+        doc.addPage({
+          size: [page.actualWidth, page.actualHeight],
+          margin: 0
+        });
+      }
+      try {
+        SVGtoPDF(doc, page.svg, 0, 0, {
+          width: page.actualWidth,
+          height: page.actualHeight,
+          assumePt: true
+        });
+      } catch (error) {
+        console.error(`Error rendering page ${page.name}:`, error);
+      }
+    });
+    doc.end();
+    stream.on("finish", () => resolve());
+    stream.on("error", (err) => reject(err));
+  });
+}
+
+// src/index.ts
+var version = "0.1.6";
+export {
+  exportMultipagePDF,
+  exportPNG,
+  exportSVG,
+  extractSVGDimensions,
+  hexToRgba,
+  preprocessSVGColors,
+  version
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@wire-dsl/exporters",
+  "version": "0.0.2",
+  "description": "WireDSL exporters - SVG, PNG, and PDF file export functions (Node.js only)",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "wireframe",
+    "dsl",
+    "export",
+    "svg",
+    "png",
+    "pdf",
+    "svg-to-pdf"
+  ],
+  "author": "WireDSL Contributors",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "pdfkit": "0.17.2",
+    "sharp": "0.34.5",
+    "svg-to-pdfkit": "0.1.8",
+    "@wire-dsl/engine": "0.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "25.2.0",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@typescript-eslint/parser": "8.54.0",
+    "eslint": "9.39.2",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "vitest": "4.0.18"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:ui": "vitest --ui",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix"
+  }
+}