layoutbridge-light 0.0.0-stage → 1.0.1

package/indesign/commands/83-drop-caps.js

@@ -0,0 +1,87 @@
+/*
+ * A-67 Punkt 1 (Sitzung 72) – Initialen fuer Absatzformate
+ * (define_paragraph_style) und Absaetze (set_paragraph_options), gelesen von
+ * list_paragraph_styles und den Rueckgaben.
+ *
+ * Adobe-DOM (Klasse Text/ParagraphStyle), live am 28.10.2026 an InDesign 21.6
+ * geprueft: dropCapLines (0–25, 0 = keine Initiale), dropCapCharacters
+ * (0–150), dropCapStyle (CharacterStyle, nimmt auch den Namen; ohne Format
+ * das eingebaute [Ohne]). Ein oeffnendes Anfuehrungszeichen am
+ * Absatzanfang ist ein eigenes Zeichen: mit characters 1 wird nur „ zur
+ * Initiale, mit 2 „ und der erste Buchstabe gemeinsam.
+ */
+
+var IDC_DROP_CAP_MAX_LINES = 25;
+var IDC_DROP_CAP_MAX_CHARACTERS = 150;
+
+/* drop_cap pruefen (vor jeder Aenderung); liefert { lines, characters, style, style_given } mit null fuer nicht Angegebenes. */
+function idcDropCapArg(doc, value) {
+  var out = { lines: null, characters: null, style: null, style_given: false };
+  var name;
+  if (value === null || typeof value !== 'object' || IDC.isArray(value)) {
+    IDC.fail('invalid_argument', 'drop_cap must be an object {lines, characters, character_style}.', null);
+  }
+  if (idcGiven(value.lines)) {
+    out.lines = idcCountArg(value.lines, 'drop_cap.lines', 0, IDC_DROP_CAP_MAX_LINES, 0);
+  }
+  if (idcGiven(value.characters)) {
+    out.characters = idcCountArg(value.characters, 'drop_cap.characters', 0, IDC_DROP_CAP_MAX_CHARACTERS, 0);
+  }
+  if (idcGiven(value.character_style)) {
+    name = value.character_style;
+    if (typeof name !== 'string') {
+      IDC.fail('invalid_argument', 'drop_cap.character_style must be the name of an existing character style ("" or "[None]" for none).', { value: name });
+    }
+    out.style_given = true;
+    if (name === '' || name === '[None]') {
+      out.style = idcNoneCharacterStyle(doc);
+    } else {
+      out.style = idcCharacterStyleByName(doc, name);
+      if (out.style === null) {
+        IDC.fail('not_found', 'Character style "' + name + '" (drop_cap.character_style) does not exist; create it with define_character_style first.', { style_name: name });
+      }
+    }
+  }
+  if (out.lines === null && out.characters === null && !out.style_given) {
+    IDC.fail('invalid_argument', 'drop_cap needs at least one of lines (0 = off), characters or character_style.', null);
+  }
+  return out;
+}
+
+/*
+ * Initiale an ein Format oder einen Absatz setzen. Mit lines > 0 und ohne
+ * characters bekommt ein Ziel ohne Initialzeichen eines (InDesign zeigte mit
+ * 0 Zeichen keine Initiale). Liefert ['drop_cap'] oder [].
+ */
+function idcApplyDropCap(target, spec) {
+  var current = 0;
+  if (spec === null) { return []; }
+  if (spec.lines !== null) {
+    target.dropCapLines = spec.lines;
+    if (spec.lines > 0 && spec.characters === null) {
+      try { current = Number(target.dropCapCharacters); } catch (e0) { current = 0; }
+      if (!(current > 0)) { target.dropCapCharacters = 1; }
+    }
+  }
+  if (spec.characters !== null) { target.dropCapCharacters = spec.characters; }
+  if (spec.style_given && spec.style !== null) { target.dropCapStyle = spec.style; }
+  return ['drop_cap'];
+}
+
+/*
+ * drop_cap {lines, characters, character_style} wie InDesign es fuehrt;
+ * character_style null fuer [Ohne] (lokalisierter Name, das einzige
+ * Zeichenformat mit "[" am Anfang).
+ */
+function idcReadDropCap(target) {
+  var out = { lines: null, characters: null, character_style: null };
+  var style = null, name = '';
+  out.lines = idcReadNumberLoose(target, 'dropCapLines', 0);
+  out.characters = idcReadNumberLoose(target, 'dropCapCharacters', 0);
+  try { style = target.dropCapStyle; } catch (e2) { style = null; }
+  if (idcPresent(style)) {
+    try { name = String(style.name); } catch (e3) { name = ''; }
+    if (name !== '' && name.charAt(0) !== '[') { out.character_style = name; }
+  }
+  return out;
+}

package/indesign/commands/83-indents-tabs.js

@@ -0,0 +1,264 @@
+/*
+ * Sitzung 10 (Demo-Heft-Befund 3, 05.09.2026) – Einzuege, Tabulatoren und
+ * Sprache fuer Absatzformate (define_paragraph_style) und Absaetze
+ * (set_paragraph_options).
+ *
+ * Adobe-DOM (geprueft 05.09.2026, Klasse Text): leftIndent, rightIndent,
+ * firstLineIndent, lastLineIndent (Masseinheit – hier mm, weil der
+ * Interpreter waehrend eines Befehls auf Millimeter steht); tabStops
+ * (Sammlung, add(withProperties)) mit TabStop.position, alignment
+ * (TabStopAlignment LEFT_ALIGN, CENTER_ALIGN, RIGHT_ALIGN, CHARACTER_ALIGN),
+ * leader, alignmentCharacter; appliedLanguage (Language oder
+ * LanguageWithVendors, nimmt auch String) – Language.name (lokalisiert),
+ * untranslatedName, icuLocaleName; Application.languagesWithVendors,
+ * Document.languages.
+ */
+
+var IDC_INDENT_MAX_MM = 3048; /* 8640 pt, InDesigns Grenze */
+
+function idcIndentArg(value, field, min, max) {
+  if (typeof value !== 'number' || isNaN(value) || value < min || value > max) {
+    IDC.fail('invalid_argument', field + ' must be a number from ' + min + ' to ' + max + ' (mm).', { value: value });
+  }
+  return value;
+}
+
+/* ---------------------------------------------------------- Tabulatoren */
+
+function idcTabAlignmentFor(name, field) {
+  var text = name === undefined || name === null ? 'left' : String(name);
+  if (typeof TabStopAlignment === 'undefined') {
+    IDC.fail('invalid_state', 'This runtime has no TabStopAlignment enumeration.', null);
+  }
+  if (text === 'left') { return TabStopAlignment.LEFT_ALIGN; }
+  if (text === 'center') { return TabStopAlignment.CENTER_ALIGN; }
+  if (text === 'right') { return TabStopAlignment.RIGHT_ALIGN; }
+  if (text === 'character') { return TabStopAlignment.CHARACTER_ALIGN; }
+  IDC.fail('invalid_argument', field + ' must be left, center, right or character.', { value: name });
+  return null;
+}
+
+function idcTabAlignmentName(value) {
+  if (typeof TabStopAlignment === 'undefined') { return String(value); }
+  if (IDC.enumIs(value, TabStopAlignment.LEFT_ALIGN)) { return 'left'; }
+  if (IDC.enumIs(value, TabStopAlignment.CENTER_ALIGN)) { return 'center'; }
+  if (IDC.enumIs(value, TabStopAlignment.RIGHT_ALIGN)) { return 'right'; }
+  if (IDC.enumIs(value, TabStopAlignment.CHARACTER_ALIGN)) { return 'character'; }
+  return String(value);
+}
+
+/* tab_stops[] pruefen und in DOM-Eigenschaften uebersetzen (vor jeder Aenderung). */
+function idcTabStopsArg(list) {
+  var out = [];
+  var i, spec, entry, leader, alignOn;
+  if (!IDC.isArray(list)) {
+    IDC.fail('invalid_argument', 'tab_stops must be an array of {position_mm, alignment, leader, align_on}; [] removes every tab stop.', null);
+  }
+  for (i = 0; i < list.length; i++) {
+    spec = list[i];
+    if (spec === null || typeof spec !== 'object' || IDC.isArray(spec)) {
+      IDC.fail('invalid_argument', 'tab_stops[' + i + '] must be an object {position_mm, alignment, leader, align_on}.', { index: i });
+    }
+    entry = { position: idcIndentArg(spec.position_mm, 'tab_stops[' + i + '].position_mm', 0, IDC_INDENT_MAX_MM) };
+    entry.alignment = idcTabAlignmentFor(spec.alignment, 'tab_stops[' + i + '].alignment');
+    leader = spec.leader === undefined || spec.leader === null ? '' : spec.leader;
+    if (typeof leader !== 'string' || leader.length > 8) {
+      IDC.fail('invalid_argument', 'tab_stops[' + i + '].leader must be a string of up to 8 characters (e.g. ".").', { index: i, value: spec.leader });
+    }
+    entry.leader = leader;
+    alignOn = spec.align_on === undefined || spec.align_on === null ? null : spec.align_on;
+    if (alignOn !== null && (typeof alignOn !== 'string' || alignOn.length !== 1)) {
+      IDC.fail('invalid_argument', 'tab_stops[' + i + '].align_on must be a single character (used with alignment character).', { index: i, value: spec.align_on });
+    }
+    entry.alignmentCharacter = alignOn;
+    out.push(entry);
+  }
+  return out;
+}
+
+/* Alle Tabulatoren eines Ziels entfernen und die Liste neu setzen. */
+function idcSetTabStops(target, entries) {
+  var stops, i, stop, props;
+  stops = target.tabStops;
+  for (i = stops.length - 1; i >= 0; i--) {
+    stops.item(i).remove();
+  }
+  for (i = 0; i < entries.length; i++) {
+    props = { position: entries[i].position, alignment: entries[i].alignment, leader: entries[i].leader };
+    if (entries[i].alignmentCharacter !== null) { props.alignmentCharacter = entries[i].alignmentCharacter; }
+    /*
+     * Nur add(withProperties): ein Nachsetzen der Eigenschaften am
+     * zurueckgegebenen TabStop loeschte am lebenden InDesign 21.5 die zuvor
+     * angelegten Tabulatoren (Live-Fund 05.09.2026 – von drei blieb einer).
+     */
+    stop = target.tabStops.add(props);
+  }
+}
+
+function idcReadTabStops(target) {
+  var out = [];
+  var stops, i, stop, entry;
+  try { stops = target.tabStops; } catch (e0) { return null; }
+  try {
+    for (i = 0; i < stops.length; i++) {
+      stop = stops.item(i);
+      entry = { position_mm: null, alignment: null, leader: null, align_on: null };
+      try { entry.position_mm = IDC.round(Number(stop.position)); } catch (e1) { /* bleibt null */ }
+      try { entry.alignment = idcTabAlignmentName(stop.alignment); } catch (e2) { /* bleibt null */ }
+      try { entry.leader = String(stop.leader); } catch (e3) { /* bleibt null */ }
+      if (entry.alignment === 'character') {
+        try { entry.align_on = String(stop.alignmentCharacter); } catch (e4) { /* bleibt null */ }
+      }
+      out.push(entry);
+    }
+  } catch (e5) { return null; }
+  return out;
+}
+
+/* -------------------------------------------------------------- Sprache */
+
+function idcLanguageEntry(lang) {
+  var entry = { name: null, untranslated_name: null, icu_locale: null };
+  try { entry.name = String(lang.name); } catch (e0) { /* bleibt null */ }
+  try { entry.untranslated_name = String(lang.untranslatedName); } catch (e1) { /* bleibt null */ }
+  try { entry.icu_locale = String(lang.icuLocaleName); } catch (e2) { /* bleibt null */ }
+  return entry;
+}
+
+function idcLanguageKey(text) {
+  return String(text).toLowerCase().replace(/-/g, '_');
+}
+
+/* Alle Sprachen: erst die der Anwendung (mit Anbietern), dann die des Dokuments. */
+function idcAllLanguages(doc) {
+  var out = [];
+  var seen = {};
+  var lists = [], i, j, list, lang, key;
+  try { if (app.languagesWithVendors) { lists.push(app.languagesWithVendors); } } catch (e0) { /* keine */ }
+  try { if (doc.languages) { lists.push(doc.languages); } } catch (e1) { /* keine */ }
+  for (i = 0; i < lists.length; i++) {
+    list = lists[i];
+    try {
+      for (j = 0; j < list.length; j++) {
+        lang = list.item(j);
+        try { key = String(lang.name); } catch (e2) { continue; }
+        if (IDC.hasOwn(seen, key)) { continue; }
+        seen[key] = true;
+        out.push(lang);
+      }
+    } catch (e3) { /* naechste Liste */ }
+  }
+  return out;
+}
+
+/*
+ * Sprache ueber Namen (lokalisiert), englischen Namen oder ICU-Kennung (de_DE, de-DE) finden.
+ *
+ * Eine ICU-Kennung kann mehrere Sprachen meinen: de_DE steht in InDesign 21.6
+ * fuer "Deutsch: 1996 Rechtschreibreform", "Deutsch: 2006
+ * Rechtschreibreform" und "Deutsch: Alte Rechtschreibung" (Live-Probe
+ * 09.10.2026, A-43 Nebenbefund). Bis 1.0.1 gewann die erste der Liste (1996),
+ * neue Absatzformate bekommen aber 2006. Name und unuebersetzter Name gehen
+ * weiter sofort vor; unter mehreren ICU-Treffern gewinnt die 2006er-Fassung,
+ * sonst der erste, und eine Warnung nennt die Auswahl (ctx darf fehlen).
+ */
+function idcLanguageArg(doc, value, field, ctx) {
+  var wanted, all, i, lang, entry, available = [], icuHits = [], chosen, names;
+  if (typeof value !== 'string' || value === '') {
+    IDC.fail('invalid_argument', field + ' must be a language name as InDesign shows it, its English name, or an ICU locale such as de_DE.', { value: value });
+  }
+  wanted = idcLanguageKey(value);
+  all = idcAllLanguages(doc);
+  for (i = 0; i < all.length; i++) {
+    lang = all[i];
+    entry = idcLanguageEntry(lang);
+    if ((entry.name !== null && idcLanguageKey(entry.name) === wanted) ||
+        (entry.untranslated_name !== null && idcLanguageKey(entry.untranslated_name) === wanted)) {
+      return lang;
+    }
+    if (entry.icu_locale !== null && entry.icu_locale !== '' && idcLanguageKey(entry.icu_locale) === wanted) {
+      icuHits.push({ lang: lang, entry: entry });
+    }
+    if (available.length < 120) { available.push(entry); }
+  }
+  if (icuHits.length > 0) {
+    chosen = icuHits[0];
+    for (i = 0; i < icuHits.length; i++) {
+      if (String(icuHits[i].entry.untranslated_name).indexOf('2006') >= 0 || String(icuHits[i].entry.name).indexOf('2006') >= 0) {
+        chosen = icuHits[i];
+        break;
+      }
+    }
+    if (icuHits.length > 1 && ctx) {
+      names = [];
+      for (i = 0; i < icuHits.length; i++) { names.push('"' + icuHits[i].entry.name + '"'); }
+      ctx.warn(field + ' "' + value + '" matches ' + icuHits.length + ' languages (' + names.join(', ') + '); used "' + chosen.entry.name + '". Pass the name to choose another.');
+    }
+    return chosen.lang;
+  }
+  IDC.fail('not_found', 'No language "' + value + '" in this InDesign. Use a name from available (name as shown, English name or ICU locale).',
+    { language: value, available: available });
+  return null;
+}
+
+function idcReadLanguage(target) {
+  var lang = null;
+  try { lang = target.appliedLanguage; } catch (e0) { return null; }
+  if (lang === null || lang === undefined) { return null; }
+  if (typeof lang === 'string') { return { name: lang, untranslated_name: null, icu_locale: null }; }
+  return idcLanguageEntry(lang);
+}
+
+/* ------------------------------------------------ gemeinsame Anwendung */
+
+function idcIndentTabLanguageGiven(args) {
+  return idcGiven(args.left_indent_mm) || idcGiven(args.first_line_indent_mm) || idcGiven(args.right_indent_mm) ||
+    idcGiven(args.last_line_indent_mm) || idcGiven(args.tab_stops) || idcGiven(args.language);
+}
+
+/*
+ * Einzuege, Tabulatoren und Sprache an ein Format oder einen Absatz setzen.
+ * Erst pruefen (alle Argumente), dann schreiben. Liefert die Liste der
+ * gesetzten Felder.
+ */
+function idcApplyIndentTabLanguage(doc, target, args, ctx) {
+  var applied = [];
+  var left = null, first = null, right = null, last = null, tabs = null, lang = null;
+  var currentLeft = 0;
+
+  if (idcGiven(args.left_indent_mm)) { left = idcIndentArg(args.left_indent_mm, 'left_indent_mm', 0, IDC_INDENT_MAX_MM); }
+  if (idcGiven(args.right_indent_mm)) { right = idcIndentArg(args.right_indent_mm, 'right_indent_mm', 0, IDC_INDENT_MAX_MM); }
+  if (idcGiven(args.first_line_indent_mm)) { first = idcIndentArg(args.first_line_indent_mm, 'first_line_indent_mm', -IDC_INDENT_MAX_MM, IDC_INDENT_MAX_MM); }
+  if (idcGiven(args.last_line_indent_mm)) { last = idcIndentArg(args.last_line_indent_mm, 'last_line_indent_mm', -IDC_INDENT_MAX_MM, IDC_INDENT_MAX_MM); }
+  if (idcGiven(args.tab_stops)) { tabs = idcTabStopsArg(args.tab_stops); }
+  if (idcGiven(args.language)) { lang = idcLanguageArg(doc, args.language, 'language', ctx); }
+
+  /* Ein haengender Einzug darf nicht weiter nach links als der linke Einzug reichen (InDesign lehnt das ab). */
+  if (first !== null) {
+    try { currentLeft = Number(target.leftIndent); } catch (e0) { currentLeft = 0; }
+    if (left !== null) { currentLeft = left; }
+    if (first < 0 && -first > currentLeft + 0.0001) {
+      IDC.fail('invalid_argument', 'first_line_indent_mm ' + first + ' reaches further left than the left indent (' + IDC.round(currentLeft) + ' mm); a hanging indent needs left_indent_mm >= -first_line_indent_mm.',
+        { first_line_indent_mm: first, left_indent_mm: currentLeft });
+    }
+  }
+
+  if (left !== null) { target.leftIndent = left; applied.push('left_indent_mm'); }
+  if (right !== null) { target.rightIndent = right; applied.push('right_indent_mm'); }
+  if (first !== null) { target.firstLineIndent = first; applied.push('first_line_indent_mm'); }
+  if (last !== null) { target.lastLineIndent = last; applied.push('last_line_indent_mm'); }
+  if (tabs !== null) { idcSetTabStops(target, tabs); applied.push('tab_stops'); }
+  if (lang !== null) { target.appliedLanguage = lang; applied.push('language'); }
+  return applied;
+}
+
+function idcReadIndentTabLanguage(target) {
+  return {
+    left_indent_mm: idcReadNumberLoose(target, 'leftIndent', 4),
+    first_line_indent_mm: idcReadNumberLoose(target, 'firstLineIndent', 4),
+    right_indent_mm: idcReadNumberLoose(target, 'rightIndent', 4),
+    last_line_indent_mm: idcReadNumberLoose(target, 'lastLineIndent', 4),
+    tab_stops: idcReadTabStops(target),
+    language: idcReadLanguage(target)
+  };
+}

package/indesign/commands/84-import-styles.js

@@ -0,0 +1,142 @@
+/* Wunschliste J2 Nr. 19 (Sitzung 8) – Formate aus einer Vorlage uebernehmen: import_styles. */
+
+var IDC_IMPORT_KINDS = ['paragraph', 'character', 'object', 'table', 'cell', 'swatches'];
+
+function idcImportFormatFor(kind) {
+  if (typeof ImportFormat === 'undefined') { return null; }
+  if (kind === 'paragraph') { return ImportFormat.PARAGRAPH_STYLES_FORMAT; }
+  if (kind === 'character') { return ImportFormat.CHARACTER_STYLES_FORMAT; }
+  if (kind === 'object') { return ImportFormat.OBJECT_STYLES_FORMAT; }
+  if (kind === 'table') { return ImportFormat.TABLE_STYLES_FORMAT; }
+  if (kind === 'cell') { return ImportFormat.CELL_STYLES_FORMAT; }
+  return null;
+}
+
+function idcClashStrategyFor(name) {
+  if (typeof GlobalClashResolutionStrategy === 'undefined') { return null; }
+  if (name === 'keep_existing') { return GlobalClashResolutionStrategy.DO_NOT_LOAD_THE_STYLE; }
+  if (name === 'overwrite') { return GlobalClashResolutionStrategy.LOAD_ALL_WITH_OVERWRITE; }
+  if (name === 'rename') { return GlobalClashResolutionStrategy.LOAD_ALL_WITH_RENAME; }
+  return null;
+}
+
+/* Namen einer Formatart im Dokument (Gruppen eingeschlossen). */
+function idcStyleNamesOfKind(doc, kind) {
+  var list = [], i, all = null, collection = null;
+  try {
+    if (kind === 'paragraph') { all = doc.allParagraphStyles; }
+    else if (kind === 'character') { all = doc.allCharacterStyles; }
+    else if (kind === 'object') { all = doc.allObjectStyles; }
+    else if (kind === 'table') { all = doc.allTableStyles; }
+    else if (kind === 'cell') { all = doc.allCellStyles; }
+  } catch (e0) { all = null; }
+  if (all !== null && all !== undefined) {
+    for (i = 0; i < all.length; i++) { try { list.push(String(all[i].name)); } catch (e1) { /* ohne */ } }
+    return list;
+  }
+  try {
+    if (kind === 'paragraph') { collection = doc.paragraphStyles; }
+    else if (kind === 'character') { collection = doc.characterStyles; }
+    else if (kind === 'object') { collection = doc.objectStyles; }
+    else if (kind === 'table') { collection = doc.tableStyles; }
+    else if (kind === 'cell') { collection = doc.cellStyles; }
+    else if (kind === 'swatches') { collection = doc.swatches; }
+    if (collection !== null && collection !== undefined) {
+      for (i = 0; i < collection.length; i++) { try { list.push(String(collection.item(i).name)); } catch (e2) { /* ohne */ } }
+    }
+  } catch (e3) { /* leer */ }
+  return list;
+}
+
+function idcNamesNotIn(after, before) {
+  var out = [], i, j, seen;
+  for (i = 0; i < after.length; i++) {
+    seen = false;
+    for (j = 0; j < before.length; j++) { if (before[j] === after[i]) { seen = true; break; } }
+    if (!seen) { out.push(after[i]); }
+  }
+  return out;
+}
+
+IDC.register('import_styles', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var path = args.file_path;
+    var kinds = args.kinds;
+    var onConflict = args.on_conflict === undefined || args.on_conflict === null ? 'keep_existing' : args.on_conflict;
+    var file, strategy, i, j, kind, format, before, after, added, results = {}, totalAdded = 0, lower;
+    var ownPath = '';
+
+    if (typeof path !== 'string' || path === '') {
+      IDC.fail('invalid_argument', 'file_path is required (.indd, .indt or .idml).', null);
+    }
+    lower = path.toLowerCase();
+    if (!/\.(indd|indt|idml)$/.test(lower)) {
+      IDC.fail('invalid_argument', 'file_path must end in .indd, .indt or .idml.', { file_path: path });
+    }
+    if (kinds === undefined || kinds === null) {
+      kinds = IDC_IMPORT_KINDS.slice();
+    }
+    if (!IDC.isArray(kinds) || kinds.length === 0) {
+      IDC.fail('invalid_argument', 'kinds must be a non-empty list of ' + IDC_IMPORT_KINDS.join(', ') + '.', null);
+    }
+    for (i = 0; i < kinds.length; i++) {
+      if (typeof kinds[i] !== 'string') { IDC.fail('invalid_argument', 'kinds must contain names.', { kinds: kinds }); }
+      for (j = 0; j < IDC_IMPORT_KINDS.length; j++) { if (IDC_IMPORT_KINDS[j] === kinds[i]) { break; } }
+      if (j === IDC_IMPORT_KINDS.length) {
+        IDC.fail('invalid_argument', 'Unknown kind "' + kinds[i] + '"; allowed: ' + IDC_IMPORT_KINDS.join(', ') + '.', { kind: kinds[i] });
+      }
+    }
+    if (onConflict !== 'keep_existing' && onConflict !== 'overwrite' && onConflict !== 'rename') {
+      IDC.fail('invalid_argument', 'on_conflict must be keep_existing, overwrite or rename.', { on_conflict: onConflict });
+    }
+    file = IDC.fileFor(path);
+    if (!file.exists) {
+      IDC.fail('not_found', 'File not found: ' + path, { file_path: path });
+    }
+    try { ownPath = idcDocumentPath(doc); } catch (e0) { ownPath = ''; }
+    if (ownPath !== '' && IDC.fsPath(file) === ownPath) {
+      IDC.fail('invalid_argument', 'file_path is the document itself.', { file_path: path });
+    }
+    strategy = idcClashStrategyFor(onConflict);
+    if (strategy === null) {
+      IDC.fail('invalid_state', 'This runtime has no GlobalClashResolutionStrategy enumeration.', null);
+    }
+
+    for (i = 0; i < kinds.length; i++) {
+      kind = kinds[i];
+      before = idcStyleNamesOfKind(doc, kind);
+      try {
+        if (kind === 'swatches') {
+          doc.loadSwatches(file);
+        } else {
+          format = idcImportFormatFor(kind);
+          if (format === null) { IDC.fail('invalid_state', 'This runtime has no ImportFormat enumeration.', null); }
+          doc.importStyles(format, file, strategy);
+        }
+      } catch (e1) {
+        if (e1 && e1.isIdcError) { throw e1; }
+        IDC.fail('io_error', 'InDesign could not import ' + kind + ' styles from ' + path + ': ' + String(e1.message ? e1.message : e1),
+          { file_path: path, kind: kind, imported_so_far: results });
+      }
+      after = idcStyleNamesOfKind(doc, kind);
+      added = idcNamesNotIn(after, before);
+      totalAdded += added.length;
+      results[kind] = { before: before.length, after: after.length, added: added };
+    }
+    if (kinds.length > 0 && totalAdded === 0) {
+      ctx.warn('No new styles or swatches were added – the file had none of the requested kinds, or all names existed already (on_conflict ' + onConflict + ').');
+    }
+    if (onConflict === 'overwrite') {
+      ctx.warn('on_conflict overwrite: existing styles with the same names were replaced; the counts cannot show which.');
+    }
+    ctx.changes = { modified_document_ids: [Number(doc.id)] };
+    return {
+      file_path: IDC.fsPath(file) || path,
+      kinds: kinds,
+      on_conflict: onConflict,
+      results: results,
+      total_added: totalAdded
+    };
+  });

package/indesign/commands/85-swatches.js

@@ -0,0 +1,112 @@
+/* Wunschliste J2 Nr. 18 (Sitzung 7) – Farbfelder auflisten: list_swatches. */
+
+function idcColorSpaceName(value) {
+  if (value === undefined || value === null) { return null; }
+  if (typeof ColorSpace === 'undefined') { return String(value); }
+  if (IDC.enumIs(value, ColorSpace.RGB)) { return 'RGB'; }
+  if (IDC.enumIs(value, ColorSpace.CMYK)) { return 'CMYK'; }
+  try { if (ColorSpace.LAB !== undefined && IDC.enumIs(value, ColorSpace.LAB)) { return 'LAB'; } } catch (e0) { /* kein LAB */ }
+  try { if (ColorSpace.MIXEDINK !== undefined && IDC.enumIs(value, ColorSpace.MIXEDINK)) { return 'MIXED_INK'; } } catch (e1) { /* kein MIXEDINK */ }
+  return String(value);
+}
+
+function idcColorModelName(value) {
+  if (value === undefined || value === null) { return null; }
+  if (typeof ColorModel === 'undefined') { return String(value); }
+  if (IDC.enumIs(value, ColorModel.PROCESS)) { return 'process'; }
+  if (IDC.enumIs(value, ColorModel.SPOT)) { return 'spot'; }
+  try { if (ColorModel.REGISTRATION !== undefined && IDC.enumIs(value, ColorModel.REGISTRATION)) { return 'registration'; } } catch (e0) { /* keine */ }
+  return String(value);
+}
+
+function idcNumberList(values) {
+  var out = [];
+  var i;
+  if (!values) { return out; }
+  for (i = 0; i < values.length; i++) { out.push(IDC.round(Number(values[i]), 3)); }
+  return out;
+}
+
+/* Sammlung (colors, tints, gradients, mixedInks) durchgehen; fehlt sie, leere Liste. */
+function idcEachIn(doc, collectionName, fn) {
+  var collection = null, i, item;
+  try { collection = doc[collectionName]; } catch (e0) { collection = null; }
+  if (collection === null || collection === undefined) { return; }
+  for (i = 0; i < collection.length; i++) {
+    try { item = collection.item(i); } catch (e1) { continue; }
+    fn(item);
+  }
+}
+
+function idcDescribeColor(color) {
+  var out = { swatch_id: null, name: null, kind: 'color', space: null, model: null, values: [], tint_percent: null, base_color: null, built_in: false };
+  try { out.swatch_id = Number(color.id); } catch (e0) { /* null */ }
+  try { out.name = String(color.name); } catch (e1) { /* null */ }
+  try { out.space = idcColorSpaceName(color.space); } catch (e2) { /* null */ }
+  try { out.model = idcColorModelName(color.model); } catch (e3) { /* null */ }
+  try { out.values = idcNumberList(color.colorValue); } catch (e4) { out.values = []; }
+  out.built_in = out.name !== null && (out.name === 'Black' || out.name === 'Paper' || out.name === 'Registration' || out.name === 'None' || out.name.charAt(0) === '[');
+  return out;
+}
+
+IDC.register('list_swatches', { needs_document: true, read_only: true, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var includeBuiltIn = args.include_built_in !== false;
+    var out = [];
+    var counts = { color: 0, tint: 0, gradient: 0, mixed_ink: 0 };
+    var unnamed = 0;
+    /* Unbenannte Farben (leerer Name, z. B. Verlaufsstufen) sind per Name nicht erreichbar – nur zaehlen (Live-Fund 05.09.2026). */
+    var skipUnnamed = function (entry) {
+      if (entry.name === null || entry.name === '') { unnamed += 1; return true; }
+      return false;
+    };
+    var noneSwatch = idcNoneSwatch(doc);
+
+    if (noneSwatch !== null && includeBuiltIn) {
+      out.push({ swatch_id: Number(noneSwatch.id), name: String(noneSwatch.name), kind: 'none', space: null, model: null, values: [], tint_percent: null, base_color: null, built_in: true });
+    }
+    idcEachIn(doc, 'colors', function (color) {
+      var entry = idcDescribeColor(color);
+      if (skipUnnamed(entry)) { return; }
+      if (entry.built_in && !includeBuiltIn) { return; }
+      counts.color += 1;
+      out.push(entry);
+    });
+    idcEachIn(doc, 'tints', function (tint) {
+      var entry = { swatch_id: null, name: null, kind: 'tint', space: null, model: null, values: [], tint_percent: null, base_color: null, built_in: false };
+      try { entry.swatch_id = Number(tint.id); } catch (e0) { /* null */ }
+      try { entry.name = String(tint.name); } catch (e1) { /* null */ }
+      try { entry.tint_percent = IDC.round(Number(tint.tintValue), 3); } catch (e2) { /* null */ }
+      try { entry.base_color = String(tint.baseColor.name); } catch (e3) { /* null */ }
+      try { entry.space = idcColorSpaceName(tint.space); } catch (e4) { /* null */ }
+      try { entry.values = idcNumberList(tint.colorValue); } catch (e5) { entry.values = []; }
+      if (skipUnnamed(entry)) { return; }
+      counts.tint += 1;
+      out.push(entry);
+    });
+    idcEachIn(doc, 'gradients', function (gradient) {
+      var entry = { swatch_id: null, name: null, kind: 'gradient', space: null, model: null, values: [], tint_percent: null, base_color: null, built_in: false, stop_count: null };
+      try { entry.swatch_id = Number(gradient.id); } catch (e0) { /* null */ }
+      try { entry.name = String(gradient.name); } catch (e1) { /* null */ }
+      try { entry.stop_count = Number(gradient.gradientStops.length); } catch (e2) { /* null */ }
+      /* A-8.4: Art und Stopps. */
+      entry.type = idcGradientTypeName((function () { try { return gradient.type; } catch (e3) { return null; } })());
+      entry.stops = idcReadGradientStops(gradient);
+      if (skipUnnamed(entry)) { return; }
+      counts.gradient += 1;
+      out.push(entry);
+    });
+    idcEachIn(doc, 'mixedInks', function (ink) {
+      var entry = { swatch_id: null, name: null, kind: 'mixed_ink', space: 'MIXED_INK', model: null, values: [], tint_percent: null, base_color: null, built_in: false };
+      try { entry.swatch_id = Number(ink.id); } catch (e0) { /* null */ }
+      try { entry.name = String(ink.name); } catch (e1) { /* null */ }
+      try { entry.values = idcNumberList(ink.inkPercentages); } catch (e2) { entry.values = []; }
+      if (skipUnnamed(entry)) { return; }
+      counts.mixed_ink += 1;
+      out.push(entry);
+    });
+
+    return { swatches: out, count: out.length, counts: counts, unnamed_skipped: unnamed, include_built_in: includeBuiltIn };
+  });