@json-to-office/jto-ops 4.2.0 → 4.4.0

package/dist/index.js

@@ -1746,7 +1746,7 @@ var LINE_OR_WORD_PATTERN = /<line\s+xMin="(-?[\d.]+)"\s+yMin="(-?[\d.]+)"\s+xMax
 function parsePdfTextBbox(bboxXml) {
   const pages = [];
   for (const pageMatch of bboxXml.matchAll(PAGE_PATTERN)) {
-    const words = [];
+    const words2 = [];
     const lines = [];
     let open;
     for (const token of pageMatch[3].matchAll(LINE_OR_WORD_PATTERN)) {
@@ -1762,8 +1762,8 @@ function parsePdfTextBbox(bboxXml) {
           words: []
         };
       } else {
-        open?.words.push(words.length);
-        words.push({
+        open?.words.push(words2.length);
+        words2.push({
           xMin: Number(token[5]),
           yMin: Number(token[6]),
           xMax: Number(token[7]),
@@ -1775,7 +1775,7 @@ function parsePdfTextBbox(bboxXml) {
     pages.push({
       widthPt: Number(pageMatch[1]),
       heightPt: Number(pageMatch[2]),
-      words,
+      words: words2,
       lines
     });
   }
@@ -2052,17 +2052,108 @@ function indexDocument(pages, exclude = /* @__PURE__ */ new Set()) {
   const positions = [];
   let cursor = 0;
   pages.forEach((page, pageIndex) => {
-    page.words.forEach((word, index) => {
+    for (const index of readingOrder(page.words)) {
+      const word = page.words[index];
       const key = `${pageIndex}:${index}`;
       const fragment = exclude.has(key) ? "" : normalizeForMatch(word.text);
       refs.push({ pageIndex, word: index });
       fragments.push(fragment);
       positions.push(cursor);
       cursor += fragment.length;
-    });
+    }
   });
   return { pages, refs, fragments, positions, stream: fragments.join("") };
 }
+function readingOrder(words2) {
+  const rotated = new Set(
+    words2.map((_, i) => i).filter((i) => {
+      const w = words2[i];
+      return w.text.length > 2 && w.yMax - w.yMin > 1.5 * (w.xMax - w.xMin);
+    })
+  );
+  const upright = uprightOrder(
+    words2,
+    words2.map((_, i) => i).filter((i) => !rotated.has(i))
+  );
+  const order = [];
+  let next = 0;
+  for (let i = 0; i < words2.length; i++) {
+    if (rotated.has(i)) order.push(i);
+    else order.push(upright[next++]);
+  }
+  return order;
+}
+function uprightOrder(words2, indices) {
+  const rows = [];
+  const byY = [...indices].sort(
+    (a, b) => words2[a].yMin - words2[b].yMin || words2[a].xMin - words2[b].xMin
+  );
+  for (const i of byY) {
+    const row = rows[rows.length - 1];
+    if (row && sameRow(words2[row[0]], words2[i])) row.push(i);
+    else rows.push([i]);
+  }
+  const fragmentsOf = (row) => {
+    const sorted = [...row].sort((a, b) => words2[a].xMin - words2[b].xMin);
+    const out = [];
+    for (const i of sorted) {
+      const last = out[out.length - 1];
+      const w = words2[i];
+      const height = w.yMax - w.yMin;
+      if (last && w.xMin - last.xMax <= height / 2) {
+        last.words.push(i);
+        last.xMax = Math.max(last.xMax, w.xMax);
+      } else out.push({ xMin: w.xMin, xMax: w.xMax, words: [i] });
+    }
+    return out;
+  };
+  const fragments = rows.map(fragmentsOf);
+  const boxes = rows.map((row) => ({
+    yMin: Math.min(...row.map((i) => words2[i].yMin)),
+    yMax: Math.max(...row.map((i) => words2[i].yMax))
+  }));
+  const order = [];
+  let cluster = null;
+  const flush = () => {
+    if (!cluster) return;
+    if (!cluster.multi) {
+      for (const r of cluster.rows)
+        for (const f of fragments[r]) order.push(...f.words);
+    } else {
+      cluster.columns.sort((a, b) => a.xMin - b.xMin);
+      for (const column of cluster.columns) {
+        column.fragments.sort(
+          (a, b) => words2[a.words[0]].yMin - words2[b.words[0]].yMin || a.xMin - b.xMin
+        );
+        for (const f of column.fragments) order.push(...f.words);
+      }
+    }
+    cluster = null;
+  };
+  const overlapping = (columns, f) => columns.filter(
+    (c) => Math.min(c.xMax, f.xMax) - Math.max(c.xMin, f.xMin) > 0
+  );
+  for (let r = 0; r < rows.length; r++) {
+    const lineHeight = boxes[r].yMax - boxes[r].yMin;
+    const adjacent = cluster !== null && boxes[r].yMin - boxes[r - 1].yMax <= lineHeight * 0.9;
+    const wide = cluster !== null && fragments[r].some((f) => overlapping(cluster.columns, f).length > 1);
+    if (!adjacent || wide) flush();
+    if (!cluster) cluster = { rows: [], columns: [], multi: false };
+    cluster.rows.push(r);
+    if (fragments[r].length > 1) cluster.multi = true;
+    for (const f of fragments[r]) {
+      const hit = overlapping(cluster.columns, f)[0];
+      if (hit) {
+        hit.xMin = Math.min(hit.xMin, f.xMin);
+        hit.xMax = Math.max(hit.xMax, f.xMax);
+        hit.fragments.push(f);
+      } else
+        cluster.columns.push({ xMin: f.xMin, xMax: f.xMax, fragments: [f] });
+    }
+  }
+  flush();
+  return order;
+}
 function fragmentAt(index, offset) {
   let low = 0;
   let high = index.positions.length - 1;
@@ -2483,14 +2574,14 @@ function draftRenderedFindings(input) {
   pages.forEach((page, pageIndex) => {
     const lines = lineOfWord(page);
     const seen = /* @__PURE__ */ new Set();
-    const words = page.words;
-    const byTop = words.map((_, i) => i).sort((a, b) => words[a].yMin - words[b].yMin);
+    const words2 = page.words;
+    const byTop = words2.map((_, i) => i).sort((a, b) => words2[a].yMin - words2[b].yMin);
     for (let p = 0; p < byTop.length; p++) {
       const i = byTop[p];
-      const a = words[i];
+      const a = words2[i];
       for (let q = p + 1; q < byTop.length; q++) {
         const j = byTop[q];
-        const b = words[j];
+        const b = words2[j];
         if (b.yMin >= a.yMax) break;
         const shared = intersects(a, b);
         if (shared <= 0) continue;
@@ -2724,9 +2815,416 @@ function analyzeRenderedDocument(input, options = {}) {
     analysis
   };
 }
+
+// src/block-matrix.ts
+import {
+  blockDependencies,
+  readBlockDefinitions
+} from "@json-to-office/shared";
+var FALLBACK_FONTS = {
+  heading: { family: "DejaVu Sans" },
+  body: { family: "DejaVu Sans" }
+};
+var MATRIX_IMAGE = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAACCAYAAABytg0kAAAAFElEQVR42mNk+M9QzwAFjDAGACPuA/8fMSCgAAAAAElFTkSuQmCC";
+var WORDS = [
+  "performance",
+  "delivery",
+  "retention",
+  "operating",
+  "programme",
+  "contracted",
+  "recommendation",
+  "quarter",
+  "measurement",
+  "ownership",
+  "renewal",
+  "segment",
+  "margin",
+  "baseline",
+  "procurement",
+  "integration"
+];
+function words(count, seed, sentence) {
+  if (count <= 0) return "";
+  const out = [`Item${seed}`];
+  for (let i = 1; i < count; i += 1) out.push(WORDS[(seed + i) % WORDS.length]);
+  return sentence ? `${out.join(" ")}.` : out.join(" ");
+}
+function widestNumber(length, seed = 0) {
+  if (length <= 0) return "";
+  if (length === 1) return "9";
+  if (length < 4) return `\u2212${"9".repeat(length - 1)}`;
+  const group = (digits2) => Array.from({ length: digits2 }, (_, i) => String((i + seed) % 9 + 1)).join("").replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  let digits = 1;
+  while (group(digits + 1).length + 3 <= length) digits += 1;
+  const integer = group(digits);
+  return `\u2212${integer}.${"0".repeat(length - integer.length - 2)}`;
+}
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var NUMERIC_SLOTS = /* @__PURE__ */ new Set(["value", "delta", "cells"]);
+function stringValue(slot, name, edge, seed) {
+  if (slot.enum && slot.enum.length > 0) {
+    const values = slot.enum.map(String);
+    return edge === "max" ? values.reduce((a, b) => b.length > a.length ? b : a) : values[0];
+  }
+  if (slot.maxLength !== void 0 && NUMERIC_SLOTS.has(name)) {
+    return widestNumber(
+      edge === "max" ? slot.maxLength : Math.min(3, slot.maxLength),
+      seed
+    );
+  }
+  if (slot.maxLength !== void 0 && name === "unit") {
+    return edge === "max" ? ` \u20AC${"m".repeat(Math.max(0, slot.maxLength - 2))}`.slice(
+      0,
+      slot.maxLength
+    ) : "%";
+  }
+  if (slot.maxLength !== void 0) {
+    const target = edge === "max" ? slot.maxLength : Math.max(1, slot.minLength ?? 1);
+    let text = `Item${seed}`.slice(0, target);
+    let i = 0;
+    for (; ; ) {
+      const next = WORDS[(seed + i) % WORDS.length];
+      i += 1;
+      if (text.length + 1 + next.length > target) {
+        if (i > WORDS.length) break;
+        continue;
+      }
+      text += ` ${next}`;
+    }
+    return text;
+  }
+  const budget = slot.maxWords ?? 12;
+  const count = edge === "max" ? budget : Math.max(1, Math.min(2, budget));
+  const sentence = !slot.oneLine && slot.role !== "source";
+  if (slot.role === "source") return `Source: ${words(count - 1, seed, false)}`;
+  if (name === "number")
+    return edge === "max" ? words(count, seed, false) : "01";
+  return words(count, seed, sentence);
+}
+function componentValue(name, edge, seed) {
+  if (name === "chart") {
+    const categories = edge === "max" ? 8 : 2;
+    const series = edge === "max" ? 3 : 1;
+    return {
+      name: "chart",
+      props: {
+        type: "column",
+        valAxisTitle: edge === "max" ? `${words(3, seed, false)} (\u20ACm)` : "Revenue (\u20ACm)",
+        ...edge === "max" && { catAxisTitle: words(3, seed + 3, false) },
+        chartColors: ["primary", "secondary", "accent"].slice(0, series),
+        data: Array.from({ length: series }, (_, s) => ({
+          name: words(edge === "max" ? 3 : 1, seed + s, false),
+          // Two words per category is where LibreOffice's native chart
+          // still keeps rotated labels clear of the axis title; at three
+          // the title is drawn over them, at any category count.
+          labels: Array.from(
+            { length: categories },
+            (_2, c) => edge === "max" ? words(2, seed + c, false) : `Q${c + 1}`
+          ),
+          values: Array.from(
+            { length: categories },
+            (_2, c) => 1.2 * (c + 1) + s
+          )
+        }))
+      }
+    };
+  }
+  return {
+    name: "image",
+    props: {
+      base64: MATRIX_IMAGE,
+      width: edge === "max" ? name === "logo" ? "40%" : "100%" : "25%",
+      alt: words(6, seed, false)
+    }
+  };
+}
+function boundarySlotValue(slot, name, edge, seed = 0) {
+  switch (slot.type) {
+    case "string":
+      return stringValue(slot, name, edge, seed);
+    case "number":
+    case "integer":
+      return edge === "max" ? slot.maximum ?? 9999 : slot.minimum ?? 0;
+    case "boolean":
+      return edge === "max" ? true : slot.default ?? true;
+    case "component":
+      return componentValue(name, edge, seed);
+    case "object": {
+      const out = {};
+      for (const [key, property] of Object.entries(slot.properties ?? {})) {
+        if (edge === "min" && !property.required) continue;
+        const value = boundarySlotValue(property, key, edge, seed + key.length);
+        if (value !== void 0) out[key] = value;
+      }
+      return out;
+    }
+    case "array": {
+      const count = edge === "max" ? slot.maxItems ?? 3 : slot.minItems ?? (slot.required ? 1 : 0);
+      const item = slot.items ?? { type: "string" };
+      return Array.from(
+        { length: count },
+        (_, i) => boundarySlotValue(item, name, edge, seed + i)
+      );
+    }
+    default:
+      return void 0;
+  }
+}
+function boundaryInvocation(name, definition, edge, seed = 0, requiredRoles = []) {
+  const slots = {};
+  let offset = seed;
+  for (const [slotName, slot] of Object.entries(definition.slots)) {
+    offset += slotName.length;
+    const required = slot.required === true || slot.role !== void 0 && requiredRoles.includes(slot.role);
+    if (edge === "min" && !required) continue;
+    const value = boundarySlotValue(slot, slotName, edge, offset);
+    if (value !== void 0) slots[slotName] = value;
+  }
+  const labels = slots.labels;
+  const columns = slots.columns;
+  if (Array.isArray(labels) && Array.isArray(columns)) {
+    const cells = definition.slots.columns?.items?.properties?.cells;
+    for (const column of columns) {
+      if (isRecord(column) && Array.isArray(column.cells) && cells?.items) {
+        column.cells = labels.map(
+          (_, i) => boundarySlotValue(cells.items, "cells", edge, offset + i)
+        );
+      }
+    }
+  }
+  return { name: "block", props: { ref: name, slots } };
+}
+function overBudgetInvocation(name, definition, seed = 0) {
+  const invocation = boundaryInvocation(name, definition, "max", seed);
+  const slots = invocation.props.slots;
+  for (const [slotName, slot] of Object.entries(definition.slots)) {
+    if (slot.type === "string" && slot.maxWords !== void 0) {
+      slots[slotName] = `${words(slot.maxWords + 1, seed, !slot.oneLine)}`;
+      return { invocation, slot: slotName, kind: "words" };
+    }
+  }
+  for (const [slotName, slot] of Object.entries(definition.slots)) {
+    if (slot.type === "array" && slot.maxItems !== void 0 && Array.isArray(slots[slotName])) {
+      const items = slots[slotName];
+      slots[slotName] = [...items, items[0]];
+      return { invocation, slot: slotName, kind: "items" };
+    }
+  }
+  return void 0;
+}
+function enumerateBlockDefinitions(template, templateName) {
+  const definitions = readBlockDefinitions(template);
+  const examples = /* @__PURE__ */ new Map();
+  const walk = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(walk);
+      return;
+    }
+    if (!isRecord(node)) return;
+    const props = node.props;
+    if (node.name === "block" && isRecord(props) && typeof props.ref === "string" && !examples.has(props.ref)) {
+      examples.set(props.ref, isRecord(props.slots) ? props.slots : {});
+    }
+    walk(node.children);
+  };
+  walk(isRecord(template) ? template.children : void 0);
+  return Object.entries(definitions).map(([name, definition]) => ({
+    name,
+    template: templateName,
+    pointer: `/props/blocks/${name.replace(/~/g, "~0").replace(/\//g, "~1")}`,
+    definition,
+    ...examples.has(name) && { example: examples.get(name) }
+  }));
+}
+var CHROME = ["cover", "running-head", "section-opener"];
+function nominal(entry, name, definitions) {
+  if (!entry) return void 0;
+  if (entry.example) {
+    return {
+      name: "block",
+      props: { ref: name, slots: structuredClone(entry.example) }
+    };
+  }
+  return boundaryInvocation(name, definitions[name], "min");
+}
+function inlineImages(value) {
+  if (Array.isArray(value)) return value.map(inlineImages);
+  if (!isRecord(value)) return value;
+  if (value.name === "image" && isRecord(value.props) && typeof value.props.path === "string") {
+    const props = { ...value.props, base64: MATRIX_IMAGE };
+    delete props.path;
+    return { ...value, props };
+  }
+  if (value.name === "highcharts") return componentValue("chart", "min", 0);
+  return Object.fromEntries(
+    Object.entries(value).map(([k, v]) => [k, inlineImages(v)])
+  );
+}
+function withDefinitions(definitions, names) {
+  const out = {};
+  for (const name of names) {
+    if (!(name in definitions)) continue;
+    out[name] = definitions[name];
+    for (const dependency of blockDependencies(definitions, name)) {
+      if (dependency in definitions) out[dependency] = definitions[dependency];
+    }
+  }
+  return out;
+}
+function conditions(props, children, theme, font, canvas) {
+  const sections = children.map((child) => {
+    if (!isRecord(child) || child.name !== "section") return child;
+    const props2 = isRecord(child.props) ? child.props : {};
+    const page = isRecord(props2.page) ? props2.page : {};
+    return { ...child, props: { ...props2, page: { ...page, size: canvas } } };
+  });
+  const chart = JSON.stringify(sections).includes('"name":"chart"');
+  return {
+    name: "docx",
+    ...chart && { renderer: "office-open" },
+    props: {
+      ...props,
+      theme,
+      ...font === "fallback" && { themeOverrides: { fonts: FALLBACK_FONTS } }
+    },
+    children: sections
+  };
+}
+var BODY_COPY = words(40, 1e3, true);
+function blockCaseDocument(entries, name, edge, theme, { font = "design", canvas = "A4", requiredRoles = [] } = {}) {
+  const definitions = Object.fromEntries(
+    entries.map((e) => [e.name, e.definition])
+  );
+  const byName = new Map(entries.map((e) => [e.name, e]));
+  const under = (chrome) => chrome === name ? boundaryInvocation(name, definitions[name], edge, 0, requiredRoles) : inlineImages(nominal(byName.get(chrome), chrome, definitions));
+  const cover = under("cover");
+  const runningHead = under("running-head");
+  const opener = under("section-opener");
+  const body = [];
+  if (!CHROME.includes(name)) {
+    if (name === "footnotes" && byName.has("figure")) {
+      body.push(
+        inlineImages(nominal(byName.get("figure"), "figure", definitions))
+      );
+    }
+    body.push(
+      boundaryInvocation(name, definitions[name], edge, 0, requiredRoles)
+    );
+  }
+  body.push({ name: "paragraph", props: { text: BODY_COPY } });
+  const used = /* @__PURE__ */ new Set([
+    name,
+    ...CHROME,
+    ...name === "footnotes" ? ["figure"] : []
+  ]);
+  const children = [];
+  if (cover) children.push({ name: "section", children: [cover] });
+  children.push({
+    name: "section",
+    children: [runningHead, opener, ...body].filter((c) => c !== void 0)
+  });
+  return conditions(
+    {
+      metadata: {
+        title: "Boundary report",
+        author: "jto-ops block matrix",
+        company: "Example client",
+        date: "September 2026"
+      },
+      blocks: withDefinitions(definitions, used)
+    },
+    children,
+    theme,
+    font,
+    canvas
+  );
+}
+function reportCaseDocument(template, edge, theme, { font = "design", canvas = "A4", requiredRoles = [] } = {}) {
+  if (!isRecord(template) || !isRecord(template.props))
+    throw new Error("A template is a document with props.");
+  const definitions = readBlockDefinitions(template);
+  let seed = 0;
+  const rewrite = (node) => {
+    if (Array.isArray(node)) return node.map(rewrite);
+    if (!isRecord(node)) return node;
+    const props2 = node.props;
+    if (node.name === "block" && isRecord(props2) && typeof props2.ref === "string" && definitions[props2.ref]) {
+      seed += 7;
+      return boundaryInvocation(
+        props2.ref,
+        definitions[props2.ref],
+        edge,
+        seed,
+        requiredRoles
+      );
+    }
+    if (node.name === "paragraph" && isRecord(props2) && typeof props2.text === "string") {
+      return {
+        ...node,
+        props: { ...props2, text: edge === "max" ? BODY_COPY : props2.text }
+      };
+    }
+    return Array.isArray(node.children) ? { ...node, children: rewrite(node.children) } : node;
+  };
+  const props = structuredClone(template.props);
+  delete props.theme;
+  delete props.themeOverrides;
+  return conditions(
+    props,
+    rewrite(template.children),
+    theme,
+    font,
+    canvas
+  );
+}
+function generateBlockMatrix(template, templateName, options) {
+  const entries = enumerateBlockDefinitions(template, templateName);
+  const fonts = options.fonts ?? ["design", "fallback"];
+  const edges = options.edges ?? ["min", "max"];
+  const canvases = options.canvases ?? ["A4"];
+  const cases = [];
+  for (const theme of options.themes)
+    for (const font of fonts)
+      for (const canvas of canvases)
+        for (const edge of edges) {
+          if (options.blocks !== false)
+            for (const entry of entries)
+              cases.push({
+                id: `${entry.name}@${edge}/${theme}/${font}/${canvas}`,
+                block: entry.name,
+                edge,
+                theme,
+                font,
+                canvas,
+                document: blockCaseDocument(entries, entry.name, edge, theme, {
+                  font,
+                  canvas,
+                  requiredRoles: options.requiredRoles
+                })
+              });
+          if (options.report !== false)
+            cases.push({
+              id: `report@${edge}/${theme}/${font}/${canvas}`,
+              block: "report",
+              edge,
+              theme,
+              font,
+              canvas,
+              document: reportCaseDocument(template, edge, theme, {
+                font,
+                canvas,
+                requiredRoles: options.requiredRoles
+              })
+            });
+        }
+  return cases;
+}
 export {
   DocxFormatAdapter,
+  FALLBACK_FONTS,
   FontconfigStager,
+  MATRIX_IMAGE,
   MacOSCoreTextStager,
   NoopFontStager,
   PptxFormatAdapter,
@@ -2736,22 +3234,31 @@ export {
   analyzeRenderedDocument,
   assignInventory,
   authoredTextForMatch,
+  blockCaseDocument,
+  boundaryInvocation,
+  boundarySlotValue,
   clearRasterizerCache,
   createAdapter,
   createLibreOfficePptxBatchRasterizer,
   createLibreOfficePptxRasterizer,
   emitDiagnostic,
+  enumerateBlockDefinitions,
   extractPdfFonts,
   extractPdfTextGeometry,
   familyRendered,
+  generateBlockMatrix,
   getFontStager,
   getRasterizerCacheStats,
   normalizeForMatch,
+  overBudgetInvocation,
   parsePdfFonts,
   parsePdfTextBbox,
   pdffontsAvailable,
   pdftotextAvailable,
+  readingOrder,
+  reportCaseDocument,
   runWithDiagnosticSink,
-  stderrDiagnosticSink
+  stderrDiagnosticSink,
+  widestNumber
 };
 //# sourceMappingURL=index.js.map