@uurtech/jdf-cli 0.1.4 → 0.1.6

package/dist/index.js

@@ -1,31 +1,63 @@
 #!/usr/bin/env node
 import fs from 'fs';
-import path from 'path';
+import path2 from 'path';
 import { fileURLToPath } from 'url';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
+import JSZip from 'jszip';
 
-var __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
+// ../../packages/jdf-core/src/manifest.ts
+var JDFX_MANIFEST_VERSION = "1.0.0";
+var JDFX_DOCUMENT_PATH = "document.json";
+var JDFX_MANIFEST_PATH = "manifest.json";
+var JDFX_ASSET_DIR = "assets";
+
+// src/commands/validate.ts
+var __dirname$1 = path2.dirname(fileURLToPath(import.meta.url));
 function resolveSchemaPath() {
-  const bundled = path.resolve(__dirname$1, "jdf-schema.json");
+  const bundled = path2.resolve(__dirname$1, "jdf-schema.json");
   if (fs.existsSync(bundled)) return bundled;
-  const dev = path.resolve(__dirname$1, "../../../../spec/jdf-schema.json");
+  const dev = path2.resolve(__dirname$1, "../../../../spec/jdf-schema.json");
   return dev;
 }
 var SCHEMA_PATH = resolveSchemaPath();
+async function loadDocument(filePath) {
+  if (filePath.toLowerCase().endsWith(".jdfx")) {
+    const zip = await JSZip.loadAsync(fs.readFileSync(filePath));
+    const docFile = zip.file(JDFX_DOCUMENT_PATH);
+    if (!docFile) {
+      console.error(`\u2717 Bundle missing ${JDFX_DOCUMENT_PATH}`);
+      return null;
+    }
+    const doc = JSON.parse(await docFile.async("string"));
+    let manifest = null;
+    const mf = zip.file(JDFX_MANIFEST_PATH);
+    if (mf) {
+      try {
+        manifest = JSON.parse(await mf.async("string"));
+      } catch {
+      }
+    }
+    const assetCount = Object.values(zip.files).filter((f) => !f.dir && f.name.startsWith("assets/")).length;
+    return { doc, bundle: { manifest, assetCount } };
+  }
+  return { doc: JSON.parse(fs.readFileSync(filePath, "utf-8")) };
+}
 async function validate(file) {
-  const filePath = path.resolve(file);
+  const filePath = path2.resolve(file);
   if (!fs.existsSync(filePath)) {
     console.error(`File not found: ${filePath}`);
     return false;
   }
-  let doc;
+  let loaded;
   try {
-    doc = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    loaded = await loadDocument(filePath);
   } catch (e) {
-    console.error(`Invalid JSON: ${e.message}`);
+    console.error(`Invalid file: ${e.message}`);
     return false;
   }
+  if (!loaded) return false;
+  const { doc, bundle } = loaded;
   if (!fs.existsSync(SCHEMA_PATH)) {
     console.error(`Schema not found at ${SCHEMA_PATH}`);
     return false;
@@ -39,33 +71,161 @@ async function validate(file) {
     const d = doc;
     const pageCount = Array.isArray(d.pages) ? d.pages.length : 0;
     const elCount = Array.isArray(d.pages) ? d.pages.reduce((acc, p) => acc + (Array.isArray(p?.elements) ? p.elements.length : 0), 0) : 0;
-    console.log(`\u2713 Valid: ${path.basename(filePath)}`);
-    console.log(`  Format:    ${d.$jdf}`);
+    console.log(`\u2713 Valid: ${path2.basename(filePath)}`);
+    console.log(`  Format:    ${d.$jdf}${bundle ? " (jdfx bundle)" : ""}`);
     console.log(`  Title:     ${d.meta?.title}`);
     console.log(`  Pages:     ${pageCount}`);
     console.log(`  Elements:  ${elCount}`);
+    if (bundle) {
+      console.log(`  Assets:    ${bundle.assetCount}`);
+      if (bundle.manifest?.generator) {
+        console.log(`  Generator: ${bundle.manifest.generator}`);
+      }
+    }
     return true;
   }
-  console.error(`\u2717 Invalid: ${path.basename(filePath)}`);
+  console.error(`\u2717 Invalid: ${path2.basename(filePath)}`);
   for (const err of validateFn.errors || []) {
     const loc = err.instancePath || "(root)";
     console.error(`  ${loc} \u2014 ${err.message}`);
   }
   return false;
 }
+var GENERATOR = "@uurtech/jdf-cli";
+function decodeBase64(s) {
+  return Buffer.from(s, "base64");
+}
+function extractAssets(doc) {
+  const assets = [];
+  const cloned = JSON.parse(JSON.stringify(doc));
+  let counter = 0;
+  function walk(els) {
+    if (!els) return;
+    for (const el of els) {
+      if (el?.type === "image" && typeof el.src === "string" && el.src.startsWith("data:")) {
+        const m = el.src.match(/^data:([^;]+);base64,(.*)$/);
+        if (m) {
+          counter++;
+          const id = `asset-${counter}`;
+          const mimeType = m[1];
+          const ext = mimeType.split("/")[1]?.replace("jpeg", "jpg") || "bin";
+          assets.push({ id, bytes: decodeBase64(m[2]), mimeType, ext });
+          delete el.src;
+          el.resource = id;
+        }
+      }
+      if (el?.elements) walk(el.elements);
+      if (el?.children) walk(el.children);
+    }
+  }
+  for (const page of cloned.pages || []) walk(page.elements);
+  if (cloned.resources?.images) {
+    for (const [key, res] of Object.entries(cloned.resources.images)) {
+      if (!res || typeof res !== "object" || !("data" in res) || !res.data) continue;
+      const data = String(res.data);
+      const m = data.match(/^data:([^;]+);base64,(.*)$/);
+      const b64 = m ? m[2] : data;
+      const mimeType = m ? m[1] : res.mimeType || "image/png";
+      const ext = mimeType.split("/")[1]?.replace("jpeg", "jpg") || "bin";
+      counter++;
+      const id = key || `asset-${counter}`;
+      assets.push({ id, bytes: decodeBase64(b64), mimeType, ext });
+    }
+    cloned.resources.images = {};
+  }
+  return { doc: cloned, assets };
+}
+async function packJdfx(doc) {
+  const { doc: rewritten, assets } = extractAssets(doc);
+  const zip = new JSZip();
+  const assetEntries = assets.map((a) => {
+    const p = `${JDFX_ASSET_DIR}/${a.id}.${a.ext}`;
+    zip.file(p, a.bytes);
+    return { id: a.id, path: p, mimeType: a.mimeType, size: a.bytes.length };
+  });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const manifest = {
+    format: "jdfx",
+    version: JDFX_MANIFEST_VERSION,
+    document: JDFX_DOCUMENT_PATH,
+    created: now,
+    modified: now,
+    generator: GENERATOR,
+    assets: assetEntries
+  };
+  zip.file(JDFX_DOCUMENT_PATH, JSON.stringify(rewritten, null, 2));
+  zip.file(JDFX_MANIFEST_PATH, JSON.stringify(manifest, null, 2));
+  const bytes = await zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE", compressionOptions: { level: 6 } });
+  return { bytes, manifest };
+}
+function shouldUseJdfx(doc) {
+  const images = doc.resources?.images ?? {};
+  for (const v of Object.values(images)) {
+    if (v && typeof v === "object" && "data" in v && v.data) return true;
+  }
+  function walk(els) {
+    if (!els) return false;
+    for (const el of els) {
+      if (el?.type === "image" && typeof el.src === "string" && el.src.startsWith("data:")) return true;
+      if (el?.elements && walk(el.elements)) return true;
+      if (el?.children && walk(el.children)) return true;
+    }
+    return false;
+  }
+  for (const page of doc.pages || []) {
+    if (walk(page.elements)) return true;
+  }
+  return false;
+}
+
+// src/commands/import-md.ts
 async function importMarkdown(inputPath, outputPath) {
-  const input = path.resolve(inputPath);
-  const output = outputPath ? path.resolve(outputPath) : input.replace(/\.(md|markdown)$/i, ".jdf");
+  const input = path2.resolve(inputPath);
   console.log(`Importing: ${input}`);
-  console.log(`Output:    ${output}`);
   const content = fs.readFileSync(input, "utf-8");
-  const doc = convertMarkdownToJdf(content, path.basename(input, path.extname(input)));
-  fs.writeFileSync(output, JSON.stringify(doc, null, 2));
-  console.log(`
+  const doc = convertMarkdownToJdf(content, path2.basename(input, path2.extname(input)), path2.dirname(input));
+  let output;
+  if (outputPath) {
+    output = path2.resolve(outputPath);
+  } else {
+    const stem = input.replace(/\.(md|markdown)$/i, "");
+    output = stem + (shouldUseJdfx(doc) ? ".jdfx" : ".jdf");
+  }
+  console.log(`Output:    ${output}`);
+  if (output.toLowerCase().endsWith(".jdfx")) {
+    const { bytes, manifest } = await packJdfx(doc);
+    fs.writeFileSync(output, bytes);
+    console.log(`
+Done! Created ${doc.pages.length} page(s), ${manifest.assets.length} asset(s) bundled`);
+  } else {
+    fs.writeFileSync(output, JSON.stringify(doc, null, 2));
+    console.log(`
 Done! Created ${doc.pages.length} page(s)`);
+  }
   console.log(`Open with: open -a "JDF Reader" "${output}"`);
 }
-function convertMarkdownToJdf(md, title) {
+var MIME_BY_EXT2 = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  bmp: "image/bmp"
+};
+function resolveImageSrc(src, baseDir) {
+  if (/^(https?:|data:|file:)/i.test(src)) return src;
+  const abs = path2.isAbsolute(src) ? src : path2.resolve(baseDir, src);
+  try {
+    const bytes = fs.readFileSync(abs);
+    const ext = path2.extname(abs).slice(1).toLowerCase();
+    const mime = MIME_BY_EXT2[ext] || "application/octet-stream";
+    return `data:${mime};base64,${bytes.toString("base64")}`;
+  } catch {
+    return src;
+  }
+}
+function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
   const maxY = 247;
   const contentWidth = 166;
   const pages = [];
@@ -105,6 +265,30 @@ function convertMarkdownToJdf(md, title) {
       i++;
       continue;
     }
+    const imageMatch = line.match(/^\s*!\[([^\]]*)\]\(\s*([^)\s]+)[^)]*\)\s*$/);
+    if (imageMatch) {
+      const alt = imageMatch[1];
+      const src = resolveImageSrc(imageMatch[2], baseDir);
+      const height2 = 60;
+      if (y + height2 > maxY) {
+        pages.push({ id: `page-${pageNum}`, elements });
+        elements = [];
+        y = 5;
+        pageNum++;
+      }
+      elements.push({
+        type: "image",
+        src,
+        alt,
+        position: { x: 0, y },
+        width: contentWidth,
+        height: height2,
+        fit: "contain"
+      });
+      y += height2 + 4;
+      i++;
+      continue;
+    }
     if (line.match(/^\s*[-*+]\s/)) {
       const items = [];
       while (i < lines.length && lines[i].match(/^\s*[-*+]\s/)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uurtech/jdf-cli",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Command-line tool for the JDF (JSON Document Format) — validate and convert documents.",
   "license": "MIT",
   "author": "Ugur Kazdal",
@@ -45,7 +45,8 @@
   },
   "dependencies": {
     "ajv": "^8.17.1",
-    "ajv-formats": "^3.0.1"
+    "ajv-formats": "^3.0.1",
+    "jszip": "^3.10.1"
   },
   "devDependencies": {
     "@jdf/core": "workspace:*",