layoutbridge-light 0.0.0-stage → 1.0.0

package/indesign/commands/78-frame-lines.js

@@ -0,0 +1,452 @@
+/*
+ * Auftrag A-7.5 (Sitzung 9) – get_frame_lines: den Umbruch direkt in
+ * InDesign lesen – Zeilen je Textspalte eines Rahmens mit Grundlinie,
+ * Story-Indizes, Absatzstellung und Kennzahlen (Hurenkind-/Schusterjungen-
+ * Verdacht, Trennstrichleitern, Leerzeilen). Rein lesend.
+ *
+ * Adobe-DOM (geprueft 05.09.2026): TextFrame.textColumns, TextFrame.lines,
+ * Line {baseline, ascent, descent, horizontalOffset, endHorizontalOffset,
+ * characters, paragraphs, words, contents}. TextColumn lieferte 404 – die
+ * Klasse ist ein Text-Objekt mit lines; ohne textColumns gilt der Rahmen
+ * als eine Spalte.
+ *
+ * Grundlinien und horizontale Lagen werden unter Bogen-Nullpunkt gelesen
+ * (Millimeter ueber die Masseinheiten-Klammer) und um den Seitenversatz
+ * verschoben – wie IDC.boundsOnPage.
+ */
+
+/* Bindestrich, weicher Trennstrich, Trennstrich, geschuetzter Trennstrich. */
+var IDC_LINE_HYPHENS = {};
+IDC_LINE_HYPHENS['-'] = 1;
+IDC_LINE_HYPHENS['\u00AD'] = 1;
+IDC_LINE_HYPHENS['\u2010'] = 1;
+IDC_LINE_HYPHENS['\u2011'] = 1;
+
+function idcIsLetter(ch) {
+  if (ch === '' || ch === null || ch === undefined) { return false; }
+  return /[A-Za-z\u00C0-\u024F\u0370-\u03FF\u0400-\u04FF]/.test(ch);
+}
+
+/* Story-Index des ersten Zeichens eines Textobjekts (Zeile, Absatz). */
+function idcTextStartIndex(textObject) {
+  try { return Number(textObject.characters.item(0).index); } catch (e) { return null; }
+}
+
+function idcTextLength(textObject) {
+  try { return Number(textObject.characters.length); } catch (e) { return null; }
+}
+
+/* Ergebnis eines everyItem()-Lesens als Array mit genau count Eintraegen, sonst null. */
+function idcBundled(value, count) {
+  if (value === null || value === undefined) { return null; }
+  if (!IDC.isArray(value)) { value = [value]; }
+  return value.length === count ? value : null;
+}
+
+/*
+ * Absaetze der Story: Startindex -> Ordnungszahl (erster Absatz mit diesem
+ * Start), einmal je Story. A-69: frueher je Rahmen und mit Laenge und
+ * Zeilenzahl jedes Absatzes der ganzen Kette – beides unbenutzt, die
+ * Zeilenzahl liest idcDescribeLine nur fuer den Absatz der Zeile.
+ * A-69 Teil 2 (Live-Probe 30.10.2026, 3185 Absaetze): paragraphs.item(i)
+ * wird mit i langsamer (16,5 s fuer alle), everyItem() liest alle Starts in
+ * 0,6 s mit denselben Werten. starts (aufsteigend) und end (Laenge der
+ * Story) tragen idcLineDataBundled; ohne everyItem() der Weg je Absatz.
+ */
+function idcParagraphMap(story) {
+  var map = { byStart: {}, count: 0, starts: null, end: null };
+  var paragraphs, i, start, starts = null;
+  try { paragraphs = story.paragraphs; map.count = Number(paragraphs.length); } catch (e0) { return map; }
+  if (map.count === 0) { return map; }
+  try { starts = idcBundled(paragraphs.everyItem().characters.firstItem().index, map.count); } catch (e1) { starts = null; }
+  if (starts !== null) {
+    for (i = 0; i < map.count; i++) {
+      start = Number(starts[i]);
+      if (i > 0 && !(start >= starts[i - 1])) { starts = null; break; }
+      starts[i] = start;
+      if (!IDC.hasOwn(map.byStart, 'k' + start)) { map.byStart['k' + start] = i; }
+    }
+  }
+  if (starts !== null) {
+    map.starts = starts;
+    try { map.end = Number(story.characters.length); } catch (e2) { map.starts = null; }
+    return map;
+  }
+  map.byStart = {};
+  for (i = 0; i < map.count; i++) {
+    start = idcTextStartIndex(paragraphs.item(i));
+    if (start !== null && !IDC.hasOwn(map.byStart, 'k' + start)) { map.byStart['k' + start] = i; }
+  }
+  return map;
+}
+
+/* Ordnungszahl des Absatzes, in dem der Story-Index liegt (letzter Start <= index). */
+function idcParagraphAt(map, index) {
+  var lo = 0, hi = map.starts.length - 1, mid;
+  if (hi < 0 || index < map.starts[0]) { return -1; }
+  while (lo < hi) {
+    mid = Math.floor((lo + hi + 1) / 2);
+    if (map.starts[mid] <= index) { lo = mid; } else { hi = mid - 1; }
+  }
+  return lo;
+}
+
+function idcParagraphOrdinal(map, startIndex) {
+  if (startIndex === null || !IDC.hasOwn(map.byStart, 'k' + startIndex)) { return null; }
+  return map.byStart['k' + startIndex];
+}
+
+/*
+ * Was alle Rahmen einer Story teilen (A-69): Absatztabelle, Lage jedes
+ * Rahmens in der Kette (frame id -> Index) und Uebersatz. check_typography
+ * legt es einmal je Story an; get_frame_lines fuer seinen einen Rahmen.
+ */
+function idcStoryLineCache(story) {
+  var cache = { map: idcParagraphMap(story), frameIndexById: {}, overset: null, paragraphLines: {} };
+  var containers, i, key;
+  try {
+    containers = story.textContainers;
+    for (i = 0; i < containers.length; i++) {
+      key = 'k' + Number(containers[i].id);
+      if (!IDC.hasOwn(cache.frameIndexById, key)) { cache.frameIndexById[key] = i; }
+    }
+  } catch (e1) { cache.frameIndexById = {}; }
+  try { cache.overset = story.overflows === true; } catch (e2) { cache.overset = null; }
+  return cache;
+}
+
+/* Spaltenbegrenzungen aus Rahmen, Innenabstand, Spaltenzahl und Steg (Seitenkoordinaten). */
+function idcColumnBounds(doc, frame, page, count) {
+  var bounds = IDC.boundsOnPage(doc, frame, page);
+  var inset = [0, 0, 0, 0];
+  var gutter = 0;
+  var out = [], i, width, x;
+  try { inset = frame.textFramePreferences.insetSpacing; } catch (e0) { inset = [0, 0, 0, 0]; }
+  if (!IDC.isArray(inset) || inset.length < 4) { inset = [0, 0, 0, 0]; }
+  try { gutter = Number(frame.textFramePreferences.textColumnGutter); } catch (e1) { gutter = 0; }
+  if (isNaN(gutter)) { gutter = 0; }
+  width = (bounds.width - Number(inset[1]) - Number(inset[3]) - (count - 1) * gutter) / count;
+  for (i = 0; i < count; i++) {
+    x = bounds.x + Number(inset[1]) + i * (width + gutter);
+    out.push({
+      x: IDC.round(x),
+      y: IDC.round(bounds.y + Number(inset[0])),
+      width: IDC.round(width),
+      height: IDC.round(bounds.height - Number(inset[0]) - Number(inset[2]))
+    });
+  }
+  return out;
+}
+
+function idcDescribeLine(doc, line, indexInColumn, map, dx, includeText) {
+  var start = idcTextStartIndex(line);
+  var length = idcTextLength(line);
+  var paragraph = null, pStart = null, pLength = null, pLines = null;
+  var contents = '', wordCount = null, geometry = {};
+
+  try { paragraph = line.paragraphs.item(0); } catch (e0) { paragraph = null; }
+  if (paragraph !== null) {
+    pStart = idcTextStartIndex(paragraph);
+    pLength = idcTextLength(paragraph);
+    try { pLines = Number(paragraph.lines.length); } catch (e1) { pLines = null; }
+  }
+  try { contents = String(line.contents); } catch (e2) { contents = ''; }
+  try { wordCount = Number(line.words.length); } catch (e3) { wordCount = null; }
+  try { geometry.baseline = Number(line.baseline); } catch (e4) { /* null */ }
+  try { geometry.ascent = IDC.inPoints(function () { return Number(line.ascent); }); } catch (e5) { /* null */ }
+  try { geometry.descent = IDC.inPoints(function () { return Number(line.descent); }); } catch (e6) { /* null */ }
+  try { geometry.left = Number(line.horizontalOffset); } catch (e7) { /* null */ }
+  try { geometry.right = Number(line.endHorizontalOffset); } catch (e8) { /* null */ }
+  return idcLineEntry(indexInColumn, start, length, pStart,
+    pStart === null || pLength === null ? null : pStart + pLength,
+    pStart === null ? null : idcParagraphOrdinal(map, pStart), pLines, contents, wordCount, geometry, dx, includeText);
+}
+
+/*
+ * Eine Zeile aus gelesenen Werten – gemeinsam fuer den Weg je Zeile
+ * (idcDescribeLine) und das gebuendelte Lesen (idcLineDataBundled), damit
+ * beide dieselbe Ausgabe liefern. pEnd = Story-Index hinter dem Absatz;
+ * geometry {baseline, left, right} in mm, {ascent, descent} in pt, fehlende
+ * Werte bleiben null.
+ */
+function idcLineEntry(indexInColumn, start, length, pStart, pEnd, pIndex, pLines, contents, wordCount, geometry, dx, includeText) {
+  var lastChar = '', out;
+  if (contents.length > 0) { lastChar = contents.charAt(contents.length - 1); }
+  if (contents.replace(/[\r\n\s]/g, '') === '') { wordCount = 0; }
+
+  out = {
+    index: indexInColumn,
+    start_index: start,
+    end_index: start === null || length === null ? null : start + length,
+    baseline_mm: null,
+    ascent_pt: null,
+    descent_pt: null,
+    left_mm: null,
+    right_mm: null,
+    paragraph_index: pIndex,
+    is_first_line_of_paragraph: pStart !== null && start === pStart,
+    is_last_line_of_paragraph: pEnd !== null && start !== null && length !== null && start + length === pEnd,
+    paragraph_line_count: pLines,
+    ends_with_hyphen: IDC.hasOwn(IDC_LINE_HYPHENS, lastChar),
+    is_empty: length !== null && (length === 0 || (length === 1 && (lastChar === '\r' || lastChar === '\n'))),
+    word_count: wordCount,
+    last_char: lastChar === '\r' ? '\\r' : lastChar
+  };
+  if (geometry.baseline !== undefined) { out.baseline_mm = IDC.round(geometry.baseline); }
+  if (geometry.ascent !== undefined) { out.ascent_pt = IDC.round(geometry.ascent, 3); }
+  if (geometry.descent !== undefined) { out.descent_pt = IDC.round(geometry.descent, 3); }
+  if (geometry.left !== undefined) { out.left_mm = IDC.round(geometry.left - dx); }
+  if (geometry.right !== undefined) { out.right_mm = IDC.round(geometry.right - dx); }
+  if (includeText) { out.text = contents.replace(/[\r\n]+$/, ''); }
+  return out;
+}
+
+/*
+ * Alle Zeilen einer Spalte (oder eines Rahmens) gebuendelt lesen (A-69 Teil 2,
+ * Live-Probe 30.10.2026: je Rahmen ~50 ms statt ~290 ms, Werte in 228 Zeilen
+ * gleich dem Weg je Zeile). Je Eigenschaft ein everyItem()-Zugriff; den Absatz
+ * jeder Zeile liefert die Absatztabelle der Story (map.starts). Zeilenzahl des
+ * Absatzes: liegen erste und letzte Zeile in dieser Spalte, wird gezaehlt,
+ * sonst einmal je Absatz paragraph.lines (in cache.paragraphLines).
+ * lean: word_count nur fuer letzte Absatzzeilen (die Regeln brauchen ihn nur
+ * dort), sonst null. Liefert null, wenn etwas nicht gebuendelt lesbar ist
+ * (z. B. eine leere Zeile) – dann gilt der Weg je Zeile.
+ */
+function idcLineDataBundled(textObject, map, dx, includeText, cache, lean) {
+  var lines, n, every, starts, lasts, contents, baselines, lefts, rights, metrics, i;
+  var entries = [], keys = [], pIndex, pStart, pEnd, start, length, word, key, firstIn = {}, lastIn = {}, countIn = {};
+  if (map.starts === null) { return null; }
+  try {
+    lines = textObject.lines;
+    n = Number(lines.length);
+    if (n === 0) { return { entries: entries, contents: [] }; }
+    every = lines.everyItem();
+    starts = idcBundled(every.index, n);
+    lasts = idcBundled(every.characters.lastItem().index, n);
+    contents = idcBundled(every.contents, n);
+    baselines = idcBundled(every.baseline, n);
+    lefts = idcBundled(every.horizontalOffset, n);
+    rights = idcBundled(every.endHorizontalOffset, n);
+    metrics = IDC.inPoints(function () { return [idcBundled(every.ascent, n), idcBundled(every.descent, n)]; });
+  } catch (e0) { return null; }
+  if (starts === null || lasts === null || contents === null || baselines === null || lefts === null || rights === null || metrics[0] === null || metrics[1] === null) { return null; }
+
+  for (i = 0; i < n; i++) {
+    start = Number(starts[i]);
+    length = Number(lasts[i]) - start + 1;
+    pIndex = idcParagraphAt(map, start);
+    if (pIndex < 0) { return null; }
+    pStart = map.starts[pIndex];
+    pEnd = pIndex + 1 < map.starts.length ? map.starts[pIndex + 1] : map.end;
+    entries.push(idcLineEntry(i, start, length, pStart, pEnd, idcParagraphOrdinal(map, pStart), null,
+      String(contents[i]), null,
+      { baseline: Number(baselines[i]), ascent: Number(metrics[0][i]), descent: Number(metrics[1][i]), left: Number(lefts[i]), right: Number(rights[i]) },
+      dx, includeText));
+    key = 'k' + pStart;
+    keys.push(key);
+    if (entries[i].is_first_line_of_paragraph) { firstIn[key] = true; }
+    if (entries[i].is_last_line_of_paragraph) { lastIn[key] = true; }
+    countIn[key] = (countIn[key] || 0) + 1;
+  }
+
+  for (i = 0; i < n; i++) {
+    key = keys[i];
+    if (firstIn[key] === true && lastIn[key] === true) {
+      entries[i].paragraph_line_count = countIn[key];
+    } else {
+      if (!IDC.hasOwn(cache.paragraphLines, key)) {
+        try { cache.paragraphLines[key] = Number(lines.item(i).paragraphs.item(0).lines.length); } catch (e1) { cache.paragraphLines[key] = null; }
+      }
+      entries[i].paragraph_line_count = cache.paragraphLines[key];
+    }
+    if (!lean || (entries[i].is_last_line_of_paragraph && !entries[i].is_empty)) {
+      word = null;
+      try { word = Number(lines.item(i).words.length); } catch (e2) { word = null; }
+      if (String(contents[i]).replace(/[\r\n\s]/g, '') === '') { word = 0; }
+      entries[i].word_count = word;
+    }
+    contents[i] = String(contents[i]);
+  }
+  return { entries: entries, contents: contents };
+}
+
+/*
+ * Automatische Trennung: der Trennstrich steht nicht im Text. Endet eine
+ * Zeile mit einem Buchstaben und beginnt die naechste Zeile desselben
+ * Absatzes mit einem Buchstaben, ist das Wort getrennt (oder erzwungen
+ * gebrochen) – ends_with_hyphen wird dann gesetzt.
+ */
+function idcMarkSoftHyphens(lines, texts) {
+  var i, a, b;
+  for (i = 0; i + 1 < lines.length; i++) {
+    a = lines[i];
+    b = lines[i + 1];
+    if (a.ends_with_hyphen) { continue; }
+    if (a.paragraph_index === null || a.paragraph_index !== b.paragraph_index) { continue; }
+    if (a.is_last_line_of_paragraph) { continue; }
+    if (idcIsLetter(texts[i].last) && idcIsLetter(texts[i + 1].first)) { a.ends_with_hyphen = true; }
+  }
+}
+
+function idcColumnFigures(lines) {
+  var out = {
+    line_count: lines.length,
+    first_baseline_mm: null,
+    last_baseline_mm: null,
+    starts_with_last_line_of_paragraph: false,
+    ends_with_first_line_of_paragraph: false,
+    starts_with_empty_line: false,
+    consecutive_hyphens_max: 0,
+    ends_with_single_word: false,
+    single_word_last_lines: []
+  };
+  var i, run = 0, first, last;
+  if (lines.length === 0) { return out; }
+  first = lines[0];
+  last = lines[lines.length - 1];
+  out.first_baseline_mm = first.baseline_mm;
+  out.last_baseline_mm = last.baseline_mm;
+  out.starts_with_last_line_of_paragraph = first.is_last_line_of_paragraph && !first.is_first_line_of_paragraph && !first.is_empty;
+  out.ends_with_first_line_of_paragraph = last.is_first_line_of_paragraph && !last.is_last_line_of_paragraph && !last.is_empty;
+  out.starts_with_empty_line = first.is_empty === true;
+  for (i = 0; i < lines.length; i++) {
+    if (lines[i].ends_with_hyphen) { run += 1; if (run > out.consecutive_hyphens_max) { out.consecutive_hyphens_max = run; } }
+    else { run = 0; }
+    if (lines[i].is_last_line_of_paragraph && !lines[i].is_empty && lines[i].word_count === 1 && lines[i].paragraph_line_count !== null && lines[i].paragraph_line_count > 1) {
+      out.single_word_last_lines.push(lines[i].index);
+    }
+  }
+  out.ends_with_single_word = last.is_last_line_of_paragraph && !last.is_empty && last.word_count === 1 && last.paragraph_line_count !== null && last.paragraph_line_count > 1;
+  return out;
+}
+
+/* Zeilen einer Spalte (TextColumn) oder des ganzen Rahmens als Array. */
+function idcLinesOf(textObject) {
+  var out = [], lines, i;
+  try { lines = textObject.lines; } catch (e0) { return out; }
+  for (i = 0; i < lines.length; i++) { out.push(lines.item(i)); }
+  return out;
+}
+
+function idcFrameColumns(frame) {
+  var out = [], columns, i;
+  try { columns = frame.textColumns; } catch (e0) { columns = null; }
+  if (columns === null || columns === undefined) { return null; }
+  try {
+    for (i = 0; i < columns.length; i++) { out.push(columns.item(i)); }
+  } catch (e1) { return null; }
+  return out;
+}
+
+/*
+ * Zeilen eines Rahmens je Spalte samt Kennzahlen – gemeinsam fuer
+ * get_frame_lines und check_typography. Warnungen gehen an ctx (null =
+ * keine). cache aus idcStoryLineCache(story); ohne wird er hier angelegt.
+ * lean (check_typography): word_count nur, wo die Regeln ihn lesen.
+ */
+function idcFrameLineData(doc, frame, story, includeText, maxLines, ctx, cache, lean) {
+  var page = null, dx = 0, columns, columnObjects, i, c, lines, entries, texts, raw, bundled, line, total = 0, truncated = false, overset = null;
+  var map, bounds, frameIndex = null, frameKey;
+
+  try { page = frame.parentPage; } catch (e0) { page = null; }
+  try { if (page !== null && page !== undefined && page.isValid !== true) { page = null; } } catch (e0b) { page = null; }
+  if (page === null || page === undefined) { page = null; }
+  dx = page === null ? 0 : IDC.spreadOffsetOfPage(page);
+
+  if (cache === undefined || cache === null) { cache = idcStoryLineCache(story); }
+  try {
+    frameKey = 'k' + Number(frame.id);
+    if (IDC.hasOwn(cache.frameIndexById, frameKey)) { frameIndex = cache.frameIndexById[frameKey]; }
+  } catch (e1) { frameIndex = null; }
+  overset = cache.overset;
+  map = cache.map;
+  columnObjects = idcFrameColumns(frame);
+  if (columnObjects === null || columnObjects.length === 0) { columnObjects = [frame]; }
+  bounds = idcColumnBounds(doc, frame, page, columnObjects.length);
+
+  columns = [];
+  for (c = 0; c < columnObjects.length; c++) {
+    bundled = idcLineDataBundled(columnObjects[c], map, dx, includeText, cache, lean === true);
+    entries = [];
+    raw = [];
+    if (bundled !== null) {
+      for (i = 0; i < bundled.entries.length; i++) {
+        if (total >= maxLines) { truncated = true; break; }
+        entries.push(bundled.entries[i]);
+        raw.push(bundled.contents[i]);
+        total += 1;
+      }
+    } else {
+      lines = idcLinesOf(columnObjects[c]);
+      for (i = 0; i < lines.length; i++) {
+        if (total >= maxLines) { truncated = true; break; }
+        line = lines[i];
+        entries.push(idcDescribeLine(doc, line, i, map, dx, includeText));
+        try { raw.push(String(line.contents)); } catch (e3) { raw.push(''); }
+        total += 1;
+      }
+    }
+    texts = [];
+    for (i = 0; i < raw.length; i++) {
+      /* Endet die Zeile mit Absatzmarke, erzwungenem Umbruch (Live-Fund 05.09.2026: initial_text mit LF) oder Zeilentrenner, ist nichts getrennt. */
+      var rawLast = raw[i].charAt(raw[i].length - 1);
+      var brokenByBreak = rawLast === '\r' || rawLast === '\n' || rawLast === '\u2028' || rawLast === '\u2029';
+      texts.push({ first: raw[i].charAt(0), last: brokenByBreak ? '' : rawLast });
+    }
+    idcMarkSoftHyphens(entries, texts);
+    var figures = idcColumnFigures(entries);
+    figures.column_index = c;
+    figures.bounds_mm = bounds[c] || null;
+    figures.lines = entries;
+    columns.push(figures);
+    if (truncated) { break; }
+  }
+  if (ctx !== null && truncated) {
+    ctx.warn('More than ' + maxLines + ' lines; output cut at max_lines (truncated true).');
+  }
+  if (ctx !== null && total === 0) {
+    ctx.warn('The frame shows no composed line – it is empty, or the text is overset before it.');
+  }
+
+  return {
+    frame_id: Number(frame.id),
+    story_id: Number(story.id),
+    frame_index: frameIndex,
+    page_id: page === null ? null : Number(page.id),
+    page_name: page === null ? '' : String(page.name),
+    paragraph_count: map.count,
+    column_count: columns.length,
+    line_count: total,
+    columns: columns,
+    overset: overset,
+    truncated: truncated
+  };
+}
+
+IDC.register('get_frame_lines', { needs_document: true, read_only: true, ruler: 'spread' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcTextFrameArg(doc, args, 'frame_id');
+    var frame = found.item;
+    var story = idcStoryOf(frame);
+    var includeText = args.include_text === true;
+    var maxLines = idcGiven(args.max_lines) ? args.max_lines : 500;
+
+    if (typeof maxLines !== 'number' || Math.floor(maxLines) !== maxLines || maxLines < 1 || maxLines > 5000) {
+      IDC.fail('invalid_argument', 'max_lines must be a whole number between 1 and 5000.', { max_lines: args.max_lines });
+    }
+    var data = idcFrameLineData(doc, frame, story, includeText, maxLines, ctx);
+    return {
+      frame_id: data.frame_id,
+      story_id: data.story_id,
+      frame_index: data.frame_index,
+      page_id: data.page_id,
+      coordinate_space: data.page_id === null ? 'spread' : 'page',
+      column_count: data.column_count,
+      line_count: data.line_count,
+      columns: data.columns,
+      overset: data.overset,
+      truncated: data.truncated
+    };
+  });