@uurtech/jdf-cli 0.2.0 → 0.2.1

package/dist/index.js

@@ -1699,6 +1699,10 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       if (arr) arr.push(op);
       else opBins.set(key, [op]);
     }
+    const sizePenalty = (op, fontSize) => {
+      if (!op.fontSize || !fontSize) return 0;
+      return Math.abs(Math.log(op.fontSize / fontSize)) * 6;
+    };
     const findOp = (x, y, fontSize) => {
       let best = null;
       let bestD = Infinity;
@@ -1708,7 +1712,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
           const arr = opBins.get(`${bx + dx},${by + dy}`);
           if (!arr) continue;
           for (const op of arr) {
-            const d = Math.hypot(op.x - x, op.y - y);
+            const d = Math.hypot(op.x - x, op.y - y) + sizePenalty(op, fontSize);
             if (d < bestD) {
               bestD = d;
               best = op;
@@ -1718,8 +1722,9 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       }
       if (best) return best;
       const tol = Math.max(2, fontSize * 0.6);
+      const sizeOk = (op) => !op.fontSize || !fontSize || op.fontSize / fontSize > 0.6 && op.fontSize / fontSize < 1.7;
       for (const op of ops.textOps) {
-        if (Math.abs(op.y - y) > tol) continue;
+        if (!sizeOk(op) || Math.abs(op.y - y) > tol) continue;
         const d = Math.abs(op.x - x) + Math.abs(op.y - y) * 4;
         if (d < bestD) {
           bestD = d;
@@ -1728,6 +1733,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       }
       if (best) return best;
       for (const op of ops.textOps) {
+        if (!sizeOk(op)) continue;
         const d = Math.hypot(op.x - x, op.y - y);
         if (d < bestD) {
           bestD = d;
@@ -1746,6 +1752,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       const conv = viewport.convertToViewportPoint(baseX, baseY);
       const vx = safeNum(conv?.[0], 0);
       const vy = safeNum(conv?.[1], 0);
+      if (fontSize < 1.5) return;
       const op = findOp(vx, vy, fontSize);
       const mode = op?.mode ?? 0;
       if (mode === 7) return;
@@ -1869,10 +1876,92 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       sizeChars.set(k, (sizeChars.get(k) ?? 0) + l.text.length);
     }
     const bodyFontSize = [...sizeChars.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 0;
+    const rowOf = /* @__PURE__ */ new Map();
+    const rowStartOf = /* @__PURE__ */ new Map();
+    const nextOnRow = /* @__PURE__ */ new Map();
+    {
+      const order = lines.map((_, i) => i).filter((i) => !consumedLines.has(i));
+      for (let a = 0; a < order.length; a++) {
+        const i = order[a], li = lines[i];
+        const tolY = Math.max(0.6, li.fontSize * PT_TO_MM2 * 0.35);
+        let bestNext = -1, bestX = Infinity;
+        for (let b = 0; b < order.length; b++) {
+          const j = order[b], lj = lines[j];
+          if (j === i || Math.abs(lj.y - li.y) > tolY || lj.x <= li.x) continue;
+          if (lj.x < bestX) {
+            bestX = lj.x;
+            bestNext = j;
+          }
+        }
+        if (bestNext >= 0) nextOnRow.set(i, bestNext);
+      }
+      const seen = /* @__PURE__ */ new Set();
+      for (const i of order) {
+        if (seen.has(i)) continue;
+        const row = [i];
+        seen.add(i);
+        let cur = i;
+        while (nextOnRow.has(cur)) {
+          const j = nextOnRow.get(cur), lc = lines[cur], lj = lines[j];
+          const em = Math.min(lc.fontSize, lj.fontSize) * PT_TO_MM2;
+          const gap = lj.x - (lc.x + lc.width);
+          if (gap < -em * 0.3 || gap > em * 0.6) break;
+          row.push(j);
+          seen.add(j);
+          cur = j;
+        }
+        rowOf.set(i, row);
+        for (const j of row) rowStartOf.set(j, i);
+      }
+    }
+    const runStyle = (l) => {
+      const cls = fontMap.get(l.fontName) || classifyFont(l.fontName || "");
+      return { cls, bold: cls.weight === "bold", italic: cls.style === "italic" };
+    };
     lines.forEach((l, lineIdx) => {
       const tableEl = tableAtLine.get(lineIdx);
       if (tableEl) elements.push(tableEl);
       if (consumedLines.has(lineIdx)) return;
+      const row = rowOf.get(lineIdx);
+      if (!row) return;
+      if (row.length > 1) {
+        const first = lines[row[0]], last = lines[row[row.length - 1]];
+        const base = runStyle(first);
+        const rowEnd = last.x + last.width;
+        const measuredW = Math.max((rowEnd - first.x) * 1.2 + first.fontSize * PT_TO_MM2 * 0.4, first.fontSize * PT_TO_MM2);
+        const nextIdx2 = nextOnRow.get(row[row.length - 1]);
+        const cap2 = nextIdx2 != null ? lines[nextIdx2].x - first.x - first.fontSize * PT_TO_MM2 * 0.3 : pageWmm - first.x;
+        const runs2 = [];
+        row.forEach((idx, k) => {
+          const r = lines[idx];
+          const st = runStyle(r);
+          let text2 = r.text;
+          if (k > 0) {
+            const prev2 = lines[row[k - 1]];
+            const gap = r.x - (prev2.x + prev2.width);
+            if (gap > r.fontSize * PT_TO_MM2 * 0.08 && !/\s$/.test(prev2.text) && !/^\s/.test(text2)) text2 = " " + text2;
+          }
+          const run = { text: text2 };
+          if (st.bold) run.bold = true;
+          if (st.italic) run.italic = true;
+          if (r.color !== "#000000") run.color = r.color;
+          if (Math.abs(r.fontSize - first.fontSize) >= 0.5) run.fontSize = Math.round(r.fontSize * 10) / 10;
+          if (st.cls.family !== base.cls.family) run.fontFamily = st.cls.family;
+          const lk = findLinkForRun2(r);
+          if (lk) run.link = lk.url ? lk.url : lk.destPage != null ? { type: "internal", target: `#page-${lk.destPage + 1}` } : void 0;
+          runs2.push(run);
+        });
+        const style2 = { fontSize: Math.round(first.fontSize * 10) / 10, fontFamily: base.cls.family };
+        if (first.opacity < 0.999) style2.opacity = Math.round(first.opacity * 100) / 100;
+        elements.push({
+          type: "richtext",
+          runs: runs2,
+          position: { x: Math.max(0, Math.round(first.x * 100) / 100), y: Math.max(0, Math.round(Math.min(...row.map((i) => lines[i].y)) * 100) / 100) },
+          width: Math.max(2, Math.round(Math.max(first.fontSize * PT_TO_MM2, Math.min(measuredW, cap2)) * 100) / 100),
+          style: style2
+        });
+        return;
+      }
       const cls = fontMap.get(l.fontName) || classifyFont(l.fontName || "");
       const style = {
         fontSize: Math.round(l.fontSize * 10) / 10,
@@ -1883,9 +1972,11 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       if (l.color !== "#000000") style.color = l.color;
       if (l.opacity < 0.999) style.opacity = Math.round(l.opacity * 100) / 100;
       const link = findLinkForRun2(l);
-      const measured = Math.max(l.width + l.fontSize * PT_TO_MM2 * 0.4, l.fontSize * PT_TO_MM2);
+      const measured = Math.max(l.width * 1.2 + l.fontSize * PT_TO_MM2 * 0.4, l.fontSize * PT_TO_MM2);
       const remaining = Math.max(measured, pageWmm - l.x);
-      const elWidth = Math.min(measured, remaining);
+      const nextIdx = nextOnRow.get(lineIdx);
+      const cap = nextIdx != null ? Math.max(l.fontSize * PT_TO_MM2, lines[nextIdx].x - l.x - l.fontSize * PT_TO_MM2 * 0.3) : Infinity;
+      const elWidth = Math.min(measured, remaining, cap);
       const text = {
         type: "text",
         content: l.text,

package/package.json

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