@uurtech/jdf-cli 0.1.21 → 0.1.22

package/dist/index.js

@@ -240,6 +240,58 @@ function shouldUseJdfx(doc) {
 }
 
 // src/commands/import-md.ts
+function parseInline(text) {
+  const runs = [];
+  let i = 0;
+  let buf = "";
+  const flush = (extra) => {
+    if (buf) {
+      runs.push({ text: buf, ...extra });
+      buf = "";
+    }
+  };
+  while (i < text.length) {
+    const rest = text.slice(i);
+    const link = rest.match(/^\[([^\]]+)\]\(([^)\s]+)[^)]*\)/);
+    if (link) {
+      flush();
+      runs.push({ text: link[1], link: link[2] });
+      i += link[0].length;
+      continue;
+    }
+    const code = rest.match(/^`([^`]+)`/);
+    if (code) {
+      flush();
+      runs.push({ text: code[1], fontFamily: "JetBrains Mono", color: "#be185d" });
+      i += code[0].length;
+      continue;
+    }
+    const bold = rest.match(/^(\*\*|__)([^]+?)\1/);
+    if (bold) {
+      flush();
+      runs.push(...parseInline(bold[2]).map((r) => ({ ...r, bold: true })));
+      i += bold[0].length;
+      continue;
+    }
+    const ital = rest.match(/^(\*|_)([^]+?)\1/);
+    if (ital) {
+      flush();
+      runs.push(...parseInline(ital[2]).map((r) => ({ ...r, italic: true })));
+      i += ital[0].length;
+      continue;
+    }
+    buf += text[i];
+    i++;
+  }
+  flush();
+  return runs.length ? runs : [{ text }];
+}
+function hasFormatting(runs) {
+  return runs.some((r) => r.bold || r.italic || r.link || r.fontFamily || r.color);
+}
+function stripInline(text) {
+  return parseInline(text).map((r) => r.text).join("");
+}
 async function importMarkdown(inputPath, outputPath) {
   const input = path2.resolve(inputPath);
   console.log(`Importing: ${input}`);
@@ -330,11 +382,28 @@ function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
       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 (line.match(/^\s*([-*_])(\s*\1){2,}\s*$/)) {
+      if (y + 6 > maxY) {
+        pages.push({ id: `page-${pageNum}`, elements });
+        elements = [];
+        y = 5;
+        pageNum++;
+      }
+      elements.push({ type: "shape", shape: "rect", position: { x: 0, y: y + 2 }, width: contentWidth, height: 0.3, fill: "#cbd5e1" });
+      y += 6;
+      i++;
+      continue;
+    }
+    if (line.includes("|") && i + 1 < lines.length && lines[i + 1].match(/^\s*\|?[\s:|-]+\|?\s*$/) && lines[i + 1].includes("-")) {
+      const splitRow = (r) => r.replace(/^\s*\|/, "").replace(/\|\s*$/, "").split("|").map((c) => stripInline(c.trim()));
+      const headers = splitRow(line);
+      i += 2;
+      const rows = [];
+      while (i < lines.length && lines[i].includes("|") && lines[i].trim() !== "") {
+        rows.push(splitRow(lines[i]));
+        i++;
+      }
+      const height2 = (rows.length + 1) * 7 + 3;
       if (y + height2 > maxY) {
         pages.push({ id: `page-${pageNum}`, elements });
         elements = [];
@@ -342,25 +411,27 @@ function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
         pageNum++;
       }
       elements.push({
-        type: "image",
-        src,
-        alt,
+        type: "table",
+        headers,
+        rows,
         position: { x: 0, y },
         width: contentWidth,
-        height: height2,
-        fit: "contain"
+        borders: true,
+        headerStyle: { backgroundColor: "#f1f5f9", fontWeight: "bold", fontSize: 10, color: "#0f172a" },
+        rowStyle: { color: "#334155", fontSize: 10 },
+        style: { fontFamily: "Inter", fontSize: 10 }
       });
-      y += height2 + 4;
-      i++;
+      y += height2;
       continue;
     }
-    if (line.match(/^\s*[-*+]\s/)) {
-      const items = [];
-      while (i < lines.length && lines[i].match(/^\s*[-*+]\s/)) {
-        items.push({ content: lines[i].replace(/^\s*[-*+]\s+/, "").trim() });
+    if (line.match(/^\s*>\s?/)) {
+      const quoteLines = [];
+      while (i < lines.length && lines[i].match(/^\s*>\s?/)) {
+        quoteLines.push(lines[i].replace(/^\s*>\s?/, ""));
         i++;
       }
-      const height2 = items.length * 5 + 3;
+      const quote = quoteLines.join(" ").trim();
+      const height2 = Math.ceil(quote.length / 70) * 4.5 + 6;
       if (y + height2 > maxY) {
         pages.push({ id: `page-${pageNum}`, elements });
         elements = [];
@@ -368,23 +439,66 @@ function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
         pageNum++;
       }
       elements.push({
-        type: "list",
-        listType: "unordered",
+        type: "text",
+        content: quote,
         position: { x: 0, y },
         width: contentWidth,
-        style: { fontFamily: "Inter", fontSize: 10, lineHeight: 1.6, color: "#334155" },
-        items
+        style: { fontFamily: "Inter", fontSize: 10, lineHeight: 1.6, color: "#475569", fontStyle: "italic", backgroundColor: "#f8fafc", padding: 10, borderRadius: 6, marginTop: 4 }
       });
       y += height2;
       continue;
     }
-    if (line.match(/^\s*\d+\.\s/)) {
-      const items = [];
-      while (i < lines.length && lines[i].match(/^\s*\d+\.\s/)) {
-        items.push({ content: lines[i].replace(/^\s*\d+\.\s+/, "").trim() });
+    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;
+    }
+    const listMatch = line.match(/^(\s*)([-*+]|\d+\.)\s/);
+    if (listMatch) {
+      const raw = [];
+      while (i < lines.length) {
+        const m = lines[i].match(/^(\s*)([-*+]|\d+\.)\s+(.*)$/);
+        if (!m) break;
+        raw.push({ indent: m[1].length, ordered: /\d/.test(m[2]), content: m[3].trim() });
         i++;
       }
-      const height2 = items.length * 5 + 3;
+      const rootOrdered = raw[0].ordered;
+      const root = [];
+      const stack = [{ indent: raw[0].indent, items: root }];
+      for (const r of raw) {
+        while (stack.length > 1 && r.indent < stack[stack.length - 1].indent) stack.pop();
+        if (r.indent > stack[stack.length - 1].indent) {
+          const parentItems = stack[stack.length - 1].items;
+          const parent = parentItems[parentItems.length - 1];
+          if (parent) {
+            parent.children = parent.children || [];
+            parent.listType = r.ordered ? "ordered" : "unordered";
+            stack.push({ indent: r.indent, items: parent.children });
+          }
+        }
+        stack[stack.length - 1].items.push({ content: stripInline(r.content) });
+      }
+      const count = raw.length;
+      const height2 = count * 5 + 3;
       if (y + height2 > maxY) {
         pages.push({ id: `page-${pageNum}`, elements });
         elements = [];
@@ -393,11 +507,11 @@ function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
       }
       elements.push({
         type: "list",
-        listType: "ordered",
+        listType: rootOrdered ? "ordered" : "unordered",
         position: { x: 0, y },
         width: contentWidth,
         style: { fontFamily: "Inter", fontSize: 10, lineHeight: 1.6, color: "#334155" },
-        items
+        items: root
       });
       y += height2;
       continue;
@@ -442,10 +556,15 @@ function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
       continue;
     }
     let para = "";
-    while (i < lines.length && lines[i].trim() !== "" && !lines[i].match(/^#{1,6}\s/) && !lines[i].match(/^\s*[-*+]\s/) && !lines[i].match(/^\s*\d+\.\s/) && !lines[i].startsWith("```")) {
+    while (i < lines.length && lines[i].trim() !== "" && !lines[i].match(/^#{1,6}\s/) && !lines[i].match(/^\s*([-*+]|\d+\.)\s/) && !lines[i].startsWith("```") && !lines[i].match(/^\s*>\s?/) && !lines[i].match(/^\s*([-*_])(\s*\1){2,}\s*$/) && !lines[i].includes("|")) {
       para += (para ? " " : "") + lines[i].trim();
       i++;
     }
+    if (!para) {
+      para = lines[i].trim();
+      i++;
+      if (!para) continue;
+    }
     const paraLines = Math.ceil(para.length / 80);
     const height = paraLines * 4.5 + 3;
     if (y + height > maxY) {
@@ -454,13 +573,24 @@ function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
       y = 5;
       pageNum++;
     }
-    elements.push({
-      type: "text",
-      content: para,
-      position: { x: 0, y },
-      width: contentWidth,
-      style: { fontFamily: "Inter", fontSize: 10, lineHeight: 1.6, color: "#334155" }
-    });
+    const runs = parseInline(para);
+    if (hasFormatting(runs)) {
+      elements.push({
+        type: "richtext",
+        runs,
+        position: { x: 0, y },
+        width: contentWidth,
+        style: { fontFamily: "Inter", fontSize: 10, lineHeight: 1.6, color: "#334155" }
+      });
+    } else {
+      elements.push({
+        type: "text",
+        content: para,
+        position: { x: 0, y },
+        width: contentWidth,
+        style: { fontFamily: "Inter", fontSize: 10, lineHeight: 1.6, color: "#334155" }
+      });
+    }
     y += height;
   }
   if (elements.length > 0) {
@@ -582,17 +712,35 @@ async function walkOps(page, OPS, viewport) {
       const y1Local = (va.y - minY) * PT_TO_MM;
       const x2Local = (vb.x - minX) * PT_TO_MM;
       const y2Local = (vb.y - minY) * PT_TO_MM;
-      shapes.push({
-        kind: "path",
-        x: minX * PT_TO_MM,
-        y: minY * PT_TO_MM,
-        width: Math.max(0.05, (maxX - minX) * PT_TO_MM),
-        height: Math.max(0.05, (maxY - minY) * PT_TO_MM),
-        stroke: isStroke ? gs.stroke : void 0,
-        strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM : void 0,
-        opacity: gs.strokeAlpha,
-        path: `M ${x1Local.toFixed(2)} ${y1Local.toFixed(2)} L ${x2Local.toFixed(2)} ${y2Local.toFixed(2)}`
-      });
+      const wLocal = Math.max(0.05, (maxX - minX) * PT_TO_MM);
+      const hLocal = Math.max(0.05, (maxY - minY) * PT_TO_MM);
+      const dx = Math.abs(va.x - vb.x);
+      const dy = Math.abs(va.y - vb.y);
+      const axisAligned = dx < 0.5 || dy < 0.5;
+      if (axisAligned) {
+        shapes.push({
+          kind: "line",
+          x: minX * PT_TO_MM,
+          y: minY * PT_TO_MM,
+          width: wLocal,
+          height: hLocal,
+          stroke: isStroke ? gs.stroke : void 0,
+          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM : void 0,
+          opacity: gs.strokeAlpha
+        });
+      } else {
+        shapes.push({
+          kind: "path",
+          x: minX * PT_TO_MM,
+          y: minY * PT_TO_MM,
+          width: wLocal,
+          height: hLocal,
+          stroke: isStroke ? gs.stroke : void 0,
+          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM : void 0,
+          opacity: gs.strokeAlpha,
+          path: `M ${x1Local.toFixed(2)} ${y1Local.toFixed(2)} L ${x2Local.toFixed(2)} ${y2Local.toFixed(2)}`
+        });
+      }
     } else if (pathSegments.length > 0) {
       const vpSegments = pathSegments.map((seg) => {
         if (seg.type === "Z") return seg;
@@ -1455,12 +1603,13 @@ The CLI exists for two workflows:
 
 Usage:
   jdf validate <file.jdf>
-  jdf import <file.{pdf,json,md}> [-o output.{jdf,jdfx}] [--json]
+  jdf convert <file.{pdf,json,md}> [-o output.{jdf,jdfx}] [--json]
   jdf --help
 
 Commands:
   validate   Validate a .jdf / .jdfx file against the JDF schema
-  import     Convert a PDF, JSON, or Markdown file into JDF
+  convert    Convert a PDF, JSON, or Markdown file into JDF
+             (alias: import)
 
 Flags:
   -o, --output <path>   Explicit output path (extension picks .jdf vs .jdfx)
@@ -1471,10 +1620,10 @@ Flags:
 
 Examples:
   jdf validate spec/examples/hello-world.jdf
-  jdf import paper.pdf                        # PDF \u2192 JDF (or .jdfx for images)
-  jdf import contract.pdf --json | jq .       # PDF \u2192 pure JSON, pipe-friendly
-  jdf import response.json -o response.jdf    # LLM JSON output \u2192 validated JDF
-  jdf import README.md
+  jdf convert paper.pdf                        # PDF \u2192 JDF (or .jdfx for images)
+  jdf convert contract.pdf --json | jq .       # PDF \u2192 pure JSON, pipe-friendly
+  jdf convert response.json -o response.jdf    # LLM JSON output \u2192 validated JDF
+  jdf convert README.md
 `;
 var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["help", "h", "json", "verbose", "skip-validate"]);
 function parseArgs(argv) {
@@ -1540,10 +1689,13 @@ async function main() {
         const ok = await validate(positional[0]);
         process.exit(ok ? 0 : 1);
       }
+      // `convert` is the headline verb; `import` stays as a back-compat alias
+      // so existing scripts and docs keep working.
+      case "convert":
       case "import": {
         const input = positional[0];
         if (!input) {
-          console.error("Usage: jdf import <file.{pdf,json,md}> [-o output.jdf] [--json]");
+          console.error("Usage: jdf convert <file.{pdf,json,md}> [-o output.jdf] [--json]");
           process.exit(1);
         }
         const output = typeof flags.output === "string" ? flags.output : void 0;

package/dist/jdf-schema.json

@@ -42,7 +42,8 @@
         "pageSize": { "$ref": "#/definitions/PageSize" },
         "pageOrientation": { "$ref": "#/definitions/PageOrientation" },
         "margins": { "$ref": "#/definitions/Margins" },
-        "unit": { "$ref": "#/definitions/Unit" }
+        "unit": { "$ref": "#/definitions/Unit" },
+        "flow": { "type": "boolean", "description": "Document-level default: lay elements out top-to-bottom and auto-paginate overflow in PDF export. Per-page `flow` overrides." }
       }
     },
     "PageSize": {
@@ -335,7 +336,7 @@
         "headers": { "type": "array", "items": { "type": "string" } },
         "rows": {
           "type": "array",
-          "items": { "type": "array", "items": { "oneOf": [{ "type": "string" }, { "type": "object", "required": ["content"], "properties": { "content": { "type": "string" }, "style": { "$ref": "#/definitions/StyleRef" }, "colspan": { "type": "integer" }, "rowspan": { "type": "integer" } } }] } }
+          "items": { "type": "array", "items": { "oneOf": [{ "type": "string" }, { "type": "object", "required": ["content"], "properties": { "content": { "type": "string" }, "style": { "$ref": "#/definitions/StyleRef" }, "align": { "type": "string", "enum": ["left","center","right","justify"] }, "colspan": { "type": "integer" }, "rowspan": { "type": "integer" } } }] } }
         },
         "position": { "$ref": "#/definitions/Position" }, "width": { "type": "number" },
         "headerStyle": { "$ref": "#/definitions/StyleRef" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uurtech/jdf-cli",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "Command-line tool for the JDF (JSON Document Format) — validate and convert documents.",
   "license": "MIT",
   "author": "Ugur Kazdal",