layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/41-shapes.js

@@ -0,0 +1,505 @@
+/*
+ * Auftrag A-8 (Sitzung 9) – Gestaltungswerkzeuge, Teil Formen und Ecken:
+ * create_ellipse (A-8.1), create_polygon (A-8.2), set_corner_options
+ * (A-8.3) und die gemeinsamen Helfer fuer Flaeche, Kontur, Farbton und
+ * Verlaufswinkel (A-8.5), die auch create_rectangle, create_line und
+ * set_frame_appearance benutzen.
+ *
+ * Adobe-DOM (Auftrag, geprueft 05.09.2026): Ovals.add(layer, at,
+ * reference, withProperties); Polygons.add(layer, numberOfSides,
+ * insetPercentage, at, reference, withProperties); Path.entirePath;
+ * fillTint/strokeTint (-1 = kein Ton); gradientFillAngle,
+ * gradientStrokeAngle, gradientFillStart, gradientFillLength;
+ * topLeftCornerOption ... bottomRightCornerRadius. Die Werte von
+ * CornerOptions sind nicht belegbar (404) – live bestaetigt (Journal).
+ */
+
+/* ------------------------------------------------------- Eckenoptionen */
+
+var IDC_CORNER_TYPES = [
+  ['none', 'NONE'],
+  ['rounded', 'ROUNDED_CORNER'],
+  ['inverse_rounded', 'INVERSE_ROUNDED_CORNER'],
+  ['bevel', 'BEVEL_CORNER'],
+  ['inset', 'INSET_CORNER'],
+  ['fancy', 'FANCY_CORNER']
+];
+
+var IDC_CORNER_NAMES = ['top_left', 'top_right', 'bottom_left', 'bottom_right'];
+var IDC_CORNER_PROPS = {
+  top_left: ['topLeftCornerOption', 'topLeftCornerRadius'],
+  top_right: ['topRightCornerOption', 'topRightCornerRadius'],
+  bottom_left: ['bottomLeftCornerOption', 'bottomLeftCornerRadius'],
+  bottom_right: ['bottomRightCornerOption', 'bottomRightCornerRadius']
+};
+
+function idcCornerTypeFor(name, field) {
+  var i;
+  if (typeof CornerOptions === 'undefined') {
+    IDC.fail('invalid_state', 'This runtime has no CornerOptions enumeration.', null);
+  }
+  for (i = 0; i < IDC_CORNER_TYPES.length; i++) {
+    if (IDC_CORNER_TYPES[i][0] === name) {
+      if (CornerOptions[IDC_CORNER_TYPES[i][1]] === undefined) {
+        IDC.fail('invalid_state', 'This InDesign version has no corner type "' + name + '" (CornerOptions.' + IDC_CORNER_TYPES[i][1] + ').', { value: name });
+      }
+      return CornerOptions[IDC_CORNER_TYPES[i][1]];
+    }
+  }
+  IDC.fail('invalid_argument', field + ' must be one of: none, rounded, inverse_rounded, bevel, inset, fancy.', { value: name });
+  return null;
+}
+
+function idcCornerTypeName(value) {
+  var i;
+  if (value === null || value === undefined || typeof CornerOptions === 'undefined') { return null; }
+  for (i = 0; i < IDC_CORNER_TYPES.length; i++) {
+    try {
+      if (CornerOptions[IDC_CORNER_TYPES[i][1]] !== undefined && IDC.enumIs(value, CornerOptions[IDC_CORNER_TYPES[i][1]])) { return IDC_CORNER_TYPES[i][0]; }
+    } catch (e) { /* weiter */ }
+  }
+  return String(value);
+}
+
+/* Ecken eines Objekts lesen: {top_left {type, radius_mm}, ...} oder null (Linien, Objekte ohne Ecken). */
+function idcReadCorners(item) {
+  var out = {}, i, name, props, type, radius, any = false;
+  for (i = 0; i < IDC_CORNER_NAMES.length; i++) {
+    name = IDC_CORNER_NAMES[i];
+    props = IDC_CORNER_PROPS[name];
+    type = null;
+    radius = null;
+    try { type = idcCornerTypeName(item[props[0]]); any = true; } catch (e0) { type = null; }
+    try { radius = IDC.round(Number(item[props[1]])); } catch (e1) { radius = null; }
+    out[name] = { type: type, radius_mm: radius };
+  }
+  if (!any) { return null; }
+  out.uniform = out.top_left.type === out.top_right.type && out.top_left.type === out.bottom_left.type && out.top_left.type === out.bottom_right.type
+    && out.top_left.radius_mm === out.top_right.radius_mm && out.top_left.radius_mm === out.bottom_left.radius_mm && out.top_left.radius_mm === out.bottom_right.radius_mm;
+  return out;
+}
+
+/* Eine Ecke setzen; radius null = unveraendert. */
+function idcSetCorner(item, name, typeName, radius) {
+  var props = IDC_CORNER_PROPS[name];
+  if (typeName !== null) { item[props[0]] = idcCornerTypeFor(typeName, 'corner type'); }
+  if (radius !== null) { item[props[1]] = radius; }
+}
+
+function idcRadiusArg(value, field) {
+  if (value === undefined || value === null) { return null; }
+  if (typeof value !== 'number' || !isFinite(value) || value < 0) {
+    IDC.fail('invalid_argument', field + ' must be a number of 0 or more (mm).', { value: value });
+  }
+  return value;
+}
+
+/* Gemeinsam fuer create_rectangle (corner_type + corner_radius_mm) und set_corner_options. */
+function idcApplyCornerArgs(item, args) {
+  var applied = false, i, name, spec, type, radius;
+  var cornerType = args.corner_type === undefined || args.corner_type === null ? null : String(args.corner_type);
+  var uniformRadius = idcRadiusArg(args.radius_mm !== undefined ? args.radius_mm : args.corner_radius_mm, args.radius_mm !== undefined ? 'radius_mm' : 'corner_radius_mm');
+  if (cornerType === null && uniformRadius !== null && uniformRadius > 0) { cornerType = 'rounded'; }
+  if (cornerType !== null || uniformRadius !== null) {
+    for (i = 0; i < IDC_CORNER_NAMES.length; i++) { idcSetCorner(item, IDC_CORNER_NAMES[i], cornerType, uniformRadius); }
+    applied = true;
+  }
+  if (args.corners !== undefined && args.corners !== null) {
+    if (typeof args.corners !== 'object' || IDC.isArray(args.corners)) {
+      IDC.fail('invalid_argument', 'corners must be an object with top_left, top_right, bottom_left, bottom_right.', { value: args.corners });
+    }
+    for (name in args.corners) {
+      if (!IDC.hasOwn(args.corners, name)) { continue; }
+      if (!IDC.hasOwn(IDC_CORNER_PROPS, name)) {
+        IDC.fail('invalid_argument', 'corners.' + name + ' is not a corner; use top_left, top_right, bottom_left, bottom_right.', { value: name });
+      }
+      spec = args.corners[name];
+      if (spec === null || typeof spec !== 'object') {
+        IDC.fail('invalid_argument', 'corners.' + name + ' must be {type, radius_mm}.', { value: spec });
+      }
+      type = spec.type === undefined || spec.type === null ? null : String(spec.type);
+      radius = idcRadiusArg(spec.radius_mm, 'corners.' + name + '.radius_mm');
+      if (type === null && radius === null) { continue; }
+      idcSetCorner(item, name, type, radius);
+      applied = true;
+    }
+  }
+  return applied;
+}
+
+/* -------------------------------------------- Flaeche, Kontur, Farbton */
+
+function idcTintArg(value, field) {
+  if (value === undefined || value === null) { return null; }
+  if (typeof value !== 'number' || !isFinite(value) || value < 0 || value > 100) {
+    IDC.fail('invalid_argument', field + ' must be a number between 0 and 100 (percent).', { value: value });
+  }
+  return value;
+}
+
+function idcAngleArg(value, field) {
+  if (value === undefined || value === null) { return null; }
+  if (typeof value !== 'number' || !isFinite(value) || value < -180 || value > 180) {
+    IDC.fail('invalid_argument', field + ' must be a number between -180 and 180 (degrees).', { value: value });
+  }
+  return value;
+}
+
+/* Art eines Farbfelds am Objekt: none|color|tint|gradient|mixed_ink. */
+function idcSwatchKind(swatch) {
+  var name = '', cls = '';
+  if (swatch === null || swatch === undefined) { return null; }
+  try { name = String(swatch.name); } catch (e0) { name = ''; }
+  if (name === 'None' || name === '[None]') { return 'none'; }
+  cls = IDC.className(swatch);
+  if (cls === 'Gradient') { return 'gradient'; }
+  if (cls === 'Tint') { return 'tint'; }
+  if (cls === 'MixedInk') { return 'mixed_ink'; }
+  return 'color';
+}
+
+/* Kontur und Flaeche mit Art, Farbton und Verlaufswinkel (A-8.5); ergaenzt idcAppearance. */
+function idcAppearanceFull(item) {
+  var out = idcAppearance(item);
+  var tint, angle, start, length;
+  try { out.fill_kind = idcSwatchKind(item.fillColor); } catch (e0) { out.fill_kind = null; }
+  try { out.stroke_kind = idcSwatchKind(item.strokeColor); } catch (e1) { out.stroke_kind = null; }
+  out.fill_tint_percent = null;
+  out.stroke_tint_percent = null;
+  out.gradient_fill_angle_deg = null;
+  out.gradient_stroke_angle_deg = null;
+  out.gradient_fill_start_mm = null;
+  out.gradient_fill_length_mm = null;
+  /* InDesign meldet -1, wenn kein Ton gesetzt ist – als null zurueckgeben (Auftrag A-8.5). */
+  try { tint = Number(item.fillTint); if (isFinite(tint) && tint >= 0) { out.fill_tint_percent = IDC.round(tint, 3); } } catch (e2) { /* null */ }
+  try { tint = Number(item.strokeTint); if (isFinite(tint) && tint >= 0) { out.stroke_tint_percent = IDC.round(tint, 3); } } catch (e3) { /* null */ }
+  if (out.fill_kind === 'gradient') {
+    try { angle = Number(item.gradientFillAngle); if (isFinite(angle)) { out.gradient_fill_angle_deg = IDC.round(angle, 3); } } catch (e4) { /* null */ }
+    try {
+      start = item.gradientFillStart;
+      if (start && start.length >= 2) { out.gradient_fill_start_mm = { x: IDC.round(Number(start[0])), y: IDC.round(Number(start[1])) }; }
+    } catch (e5) { /* null */ }
+    try { length = Number(item.gradientFillLength); if (isFinite(length)) { out.gradient_fill_length_mm = IDC.round(length); } } catch (e6) { /* null */ }
+  }
+  if (out.stroke_kind === 'gradient') {
+    try { angle = Number(item.gradientStrokeAngle); if (isFinite(angle)) { out.gradient_stroke_angle_deg = IDC.round(angle, 3); } } catch (e7) { /* null */ }
+  }
+  return out;
+}
+
+/*
+ * Flaeche, Kontur, Farbton und Verlaufswinkel aus den Aufrufparametern auf
+ * ein neues Objekt schreiben (create_ellipse, create_polygon,
+ * create_rectangle). Reihenfolge Staerke, Konturfarbe, Flaeche (Live-Fund
+ * Sitzung 3). Liefert nichts; Farbfeld-IDs neuer RGB-Felder in swatchIds.
+ */
+function idcStyleNewShape(ctx, doc, item, args, swatchIds) {
+  var fill = null, stroke = null, weight = null, none;
+  var fillTint = idcTintArg(args.fill_tint_percent, 'fill_tint_percent');
+  var strokeTint = idcTintArg(args.stroke_tint_percent, 'stroke_tint_percent');
+  var fillAngle = idcAngleArg(args.gradient_fill_angle_deg, 'gradient_fill_angle_deg');
+  var strokeAngle = idcAngleArg(args.gradient_stroke_angle_deg, 'gradient_stroke_angle_deg');
+
+  idcBothGiven(args, 'fill_hex', 'fill_swatch_name');
+  idcBothGiven(args, 'stroke_hex', 'stroke_swatch_name');
+  if (args.fill_hex !== undefined && args.fill_hex !== null) { fill = idcSwatchForHex(doc, args.fill_hex, 'fill_hex', swatchIds); }
+  if (args.fill_swatch_name !== undefined && args.fill_swatch_name !== null) { fill = idcSwatchArg(doc, args.fill_swatch_name, 'fill_swatch_name'); }
+  if (args.stroke_hex !== undefined && args.stroke_hex !== null) { stroke = idcSwatchForHex(doc, args.stroke_hex, 'stroke_hex', swatchIds); }
+  if (args.stroke_swatch_name !== undefined && args.stroke_swatch_name !== null) { stroke = idcSwatchArg(doc, args.stroke_swatch_name, 'stroke_swatch_name'); }
+  if (args.stroke_weight_pt !== undefined && args.stroke_weight_pt !== null) {
+    if (typeof args.stroke_weight_pt !== 'number' || !isFinite(args.stroke_weight_pt) || args.stroke_weight_pt < 0) {
+      IDC.fail('invalid_argument', 'stroke_weight_pt must be a number of 0 or more.', { stroke_weight_pt: args.stroke_weight_pt });
+    }
+    weight = args.stroke_weight_pt;
+  }
+
+  none = idcNoneSwatch(doc);
+  var strokeSwatch = null, strokeWeight = 0;
+  if (stroke !== null) {
+    strokeSwatch = stroke;
+    if (weight === null) { strokeWeight = 1; ctx.warn('A stroke colour without stroke_weight_pt was given; 1 pt was applied.'); }
+    else { strokeWeight = weight; }
+  } else if (weight !== null && weight > 0) {
+    strokeSwatch = idcBlackSwatch(doc) || none;
+    strokeWeight = weight;
+  } else {
+    strokeSwatch = none;
+    strokeWeight = 0;
+  }
+  idcSetStrokeWeightPt(item, strokeWeight);
+  if (strokeSwatch !== null) { item.strokeColor = strokeSwatch; }
+  if (fill !== null) { item.fillColor = fill; }
+  else if (none !== null) { item.fillColor = none; }
+
+  idcApplyTintsAndAngles(ctx, item, fillTint, strokeTint, fillAngle, strokeAngle);
+}
+
+/* Farbton und Verlaufswinkel setzen; Winkel ohne Verlauf: Warnung, Wert wird trotzdem geschrieben. */
+function idcApplyTintsAndAngles(ctx, item, fillTint, strokeTint, fillAngle, strokeAngle) {
+  if (fillTint !== null) { item.fillTint = fillTint; }
+  if (strokeTint !== null) { item.strokeTint = strokeTint; }
+  if (fillAngle !== null) {
+    if (idcSwatchKindSafe(item, 'fillColor') !== 'gradient') { ctx.warn('gradient_fill_angle_deg was set, but the fill is no gradient swatch – the angle has no visible effect until one is applied.'); }
+    item.gradientFillAngle = fillAngle;
+  }
+  if (strokeAngle !== null) {
+    if (idcSwatchKindSafe(item, 'strokeColor') !== 'gradient') { ctx.warn('gradient_stroke_angle_deg was set, but the stroke is no gradient swatch – the angle has no visible effect until one is applied.'); }
+    item.gradientStrokeAngle = strokeAngle;
+  }
+}
+
+function idcSwatchKindSafe(item, property) {
+  try { return idcSwatchKind(item[property]); } catch (e) { return null; }
+}
+
+/* Ebene fuer neue Objekte: layer_name (muss existieren), sonst die aktive. */
+function idcLayerForNew(doc, args) {
+  if (args.layer_name === undefined || args.layer_name === null) { return undefined; }
+  return idcLayerArg(doc, { layer_name: args.layer_name }).layer;
+}
+
+function idcNewShapeResult(ctx, doc, item, page, found, space, swatchIds, type, what) {
+  var landing = idcCheckLanding(ctx, item, page, what);
+  var wrap = idcTextWrapName(item);
+  if (wrap !== null && wrap !== 'none' && (ctx.args.text_wrap === undefined || ctx.args.text_wrap === null)) {
+    ctx.warn('The ' + what + ' carries text wrap (Textumfluss) "' + wrap + '" from the document defaults. Pass text_wrap: "none" or use set_text_wrap.');
+  }
+  var look = idcAppearanceFull(item);
+  var layerName = null;
+  try { layerName = String(item.itemLayer.name); } catch (e0) { layerName = null; }
+  return {
+    frame_id: Number(item.id),
+    type: type,
+    page_id: Number(page.id),
+    coordinate_space: space,
+    bounds_mm: idcItemBounds(doc, item),
+    swatch_ids: swatchIds,
+    stroke_weight_pt: look.stroke_weight_pt,
+    stroke_color: look.stroke_color,
+    stroke_kind: look.stroke_kind,
+    fill_color: look.fill_color,
+    fill_kind: look.fill_kind,
+    fill_tint_percent: look.fill_tint_percent,
+    stroke_tint_percent: look.stroke_tint_percent,
+    gradient_fill_angle_deg: look.gradient_fill_angle_deg,
+    gradient_stroke_angle_deg: look.gradient_stroke_angle_deg,
+    landed_on_page_id: landing.page_id,
+    landed_on_page_name: landing.page_name,
+    on_parent_page: found.is_parent_page,
+    text_wrap: wrap,
+    text_wrap_mode: wrap,
+    layer_name: layerName,
+    name: (function () { try { return String(item.label); } catch (e1) { return ''; } })()
+  };
+}
+
+/* Textumfluss beim Anlegen: none|bounding_box|object_shape (A-8.1); ohne Angabe Dokumentvorgabe. */
+function idcApplyCreateTextWrap(item, args) {
+  var mode = args.text_wrap;
+  if (mode === undefined || mode === null) { return; }
+  if (typeof TextWrapModes === 'undefined') { return; }
+  if (mode === 'none') { item.textWrapPreferences.textWrapMode = TextWrapModes.NONE; return; }
+  if (mode === 'bounding_box') { item.textWrapPreferences.textWrapMode = TextWrapModes.BOUNDING_BOX_TEXT_WRAP; return; }
+  if (mode === 'object_shape') { item.textWrapPreferences.textWrapMode = TextWrapModes.CONTOUR; return; }
+  IDC.fail('invalid_argument', 'text_wrap must be none, bounding_box or object_shape.', { text_wrap: mode });
+}
+
+function idcApplyName(item, args) {
+  if (args.name === undefined || args.name === null) { return; }
+  if (typeof args.name !== 'string') { IDC.fail('invalid_argument', 'name must be a string.', { name: args.name }); }
+  item.label = args.name;
+}
+
+/* ---------------------------------------------------------- create_ellipse */
+
+IDC.register('create_ellipse', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcAnyPageById(doc, args.page_id);
+    var page = found.page;
+    var rect = idcBoundsArg(args.bounds_mm, 'bounds_mm');
+    var space = idcCoordinateSpace(args);
+    var swatchIds = [];
+    var layer = idcLayerForNew(doc, args);
+    var item;
+
+    if (rect.width <= 0 || rect.height <= 0) {
+      IDC.fail('invalid_argument', 'bounds_mm.width and height must be greater than 0.', { bounds_mm: args.bounds_mm });
+    }
+    item = idcAddShape(doc, page, 'ovals', layer, idcRectToBounds(rect), space, null);
+    try {
+      idcStyleNewShape(ctx, doc, item, args, swatchIds);
+      idcApplyCreateTextWrap(item, args);
+      idcApplyName(item, args);
+    } catch (e) {
+      if (e && e.isIdcError) { throw e; }
+      IDC.fail('script_error', 'The ellipse was created (frame_id ' + Number(item.id) + ') but could not be styled: ' + String(e.message ? e.message : e), { frame_id: Number(item.id) });
+    }
+    ctx.changes = { created_frame_ids: [Number(item.id)], created_swatch_ids: swatchIds };
+    return idcNewShapeResult(ctx, doc, item, page, found, space, swatchIds, 'ellipse', 'ellipse');
+  });
+
+/*
+ * Objekt anlegen wie idcAddItem, aber mit Ebene und – fuer Polygone – der
+ * anderen add-Signatur (layer, numberOfSides, insetPercentage, at,
+ * reference, withProperties).
+ */
+function idcAddShape(doc, page, collectionName, layer, bounds, space, polygonSpec) {
+  var item;
+  var spreadBounds = idcToSpreadBounds(page, bounds, space);
+  try {
+    item = IDC.withRulerOrigin(doc, RulerOrigin.SPREAD_ORIGIN, function () {
+      var created;
+      if (polygonSpec !== null) {
+        created = page[collectionName].add(layer, polygonSpec.sides, polygonSpec.inset, undefined, undefined, { geometricBounds: spreadBounds });
+      } else {
+        created = page[collectionName].add(layer, undefined, undefined, { geometricBounds: spreadBounds });
+      }
+      return IDC.concrete(created);
+    });
+  } catch (e) {
+    IDC.fail('script_error', 'InDesign could not create the object: ' + String(e.message ? e.message : e),
+      { page_id: Number(page.id), bounds: bounds });
+  }
+  return item;
+}
+
+/* ---------------------------------------------------------- create_polygon */
+
+function idcPointsArg(points, field) {
+  var out = [], i, p;
+  if (!IDC.isArray(points) || points.length < 3 || points.length > 200) {
+    IDC.fail('invalid_argument', field + ' must be an array of 3 to 200 points {x, y}.', { count: IDC.isArray(points) ? points.length : null });
+  }
+  for (i = 0; i < points.length; i++) {
+    p = points[i];
+    if (p === null || typeof p !== 'object' || typeof p.x !== 'number' || typeof p.y !== 'number' || !isFinite(p.x) || !isFinite(p.y)) {
+      IDC.fail('invalid_argument', field + '[' + i + '] must be {x, y} in mm.', { point: p });
+    }
+    out.push({ x: p.x, y: p.y });
+  }
+  return out;
+}
+
+/* Ankerpunkte eines Pfads relativ zur Seite lesen (nur Ankerpunkte, keine Griffe). */
+function idcReadPathPoints(doc, item, page) {
+  var out = [], path, raw, i, entry, dx;
+  try { path = item.paths.item(0); raw = path.entirePath; } catch (e0) { return out; }
+  dx = page === null ? 0 : IDC.spreadOffsetOfPage(page);
+  for (i = 0; i < raw.length; i++) {
+    entry = raw[i];
+    /* Gekruemmt: [[links], [anker], [rechts]]; gerade: [x, y]. */
+    if (IDC.isArray(entry) && entry.length === 3 && IDC.isArray(entry[1])) { entry = entry[1]; }
+    if (IDC.isArray(entry) && entry.length >= 2) {
+      out.push({ x: IDC.round(Number(entry[0]) - dx), y: IDC.round(Number(entry[1])) });
+    }
+  }
+  return out;
+}
+
+IDC.register('create_polygon', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcAnyPageById(doc, args.page_id);
+    var page = found.page;
+    var space = idcCoordinateSpace(args);
+    var swatchIds = [];
+    var layer = idcLayerForNew(doc, args);
+    var hasBounds = args.bounds_mm !== undefined && args.bounds_mm !== null;
+    var hasSides = args.sides !== undefined && args.sides !== null;
+    var hasPoints = args.points_mm !== undefined && args.points_mm !== null;
+    var item, rect, sides, inset = 0, points, spreadPath, i, dx, result;
+
+    if (hasPoints && (hasBounds || hasSides || (args.star_inset_percent !== undefined && args.star_inset_percent !== null))) {
+      IDC.fail('invalid_argument', 'Pass either points_mm (free shape) or bounds_mm with sides (regular polygon or star), not both.', null);
+    }
+    if (!hasPoints && !(hasBounds && hasSides)) {
+      IDC.fail('invalid_argument', 'create_polygon needs bounds_mm and sides (3–100), or points_mm (3–200 points).', null);
+    }
+    if (hasPoints) {
+      points = idcPointsArg(args.points_mm, 'points_mm');
+      dx = IDC.spreadOffsetOfPage(page);
+      spreadPath = [];
+      for (i = 0; i < points.length; i++) { spreadPath.push([points[i].x + (space === 'spread' ? 0 : dx), points[i].y]); }
+      item = idcAddShape(doc, page, 'polygons', layer, idcRectToBounds({ x: points[0].x, y: points[0].y, width: 1, height: 1 }), space, { sides: 3, inset: 0 });
+      try {
+        IDC.withRulerOrigin(doc, RulerOrigin.SPREAD_ORIGIN, function () {
+          item.paths.item(0).entirePath = spreadPath;
+        });
+      } catch (e0) {
+        try { item.remove(); } catch (e0b) { /* bleibt liegen */ }
+        IDC.fail('script_error', 'InDesign rejected the path points: ' + String(e0.message ? e0.message : e0), { points_mm: points });
+      }
+    } else {
+      rect = idcBoundsArg(args.bounds_mm, 'bounds_mm');
+      sides = args.sides;
+      if (typeof sides !== 'number' || Math.floor(sides) !== sides || sides < 3 || sides > 100) {
+        IDC.fail('invalid_argument', 'sides must be a whole number between 3 and 100.', { sides: sides });
+      }
+      if (args.star_inset_percent !== undefined && args.star_inset_percent !== null) {
+        inset = args.star_inset_percent;
+        if (typeof inset !== 'number' || !isFinite(inset) || inset < 0 || inset > 100) {
+          IDC.fail('invalid_argument', 'star_inset_percent must be a number between 0 and 100.', { star_inset_percent: inset });
+        }
+      }
+      if (rect.width <= 0 || rect.height <= 0) {
+        IDC.fail('invalid_argument', 'bounds_mm.width and height must be greater than 0.', { bounds_mm: args.bounds_mm });
+      }
+      item = idcAddShape(doc, page, 'polygons', layer, idcRectToBounds(rect), space, { sides: sides, inset: inset });
+    }
+    try {
+      idcStyleNewShape(ctx, doc, item, args, swatchIds);
+      idcApplyCreateTextWrap(item, args);
+      idcApplyName(item, args);
+    } catch (e) {
+      if (e && e.isIdcError) { throw e; }
+      IDC.fail('script_error', 'The polygon was created (frame_id ' + Number(item.id) + ') but could not be styled: ' + String(e.message ? e.message : e), { frame_id: Number(item.id) });
+    }
+    ctx.changes = { created_frame_ids: [Number(item.id)], created_swatch_ids: swatchIds };
+    result = idcNewShapeResult(ctx, doc, item, page, found, space, swatchIds, 'polygon', 'polygon');
+    result.sides = hasPoints ? null : sides;
+    result.star_inset_percent = hasPoints ? null : inset;
+    result.points_mm = idcReadPathPoints(doc, item, IDC.landing(item).on_pasteboard ? null : (function () { try { return item.parentPage; } catch (e2) { return null; } })());
+    result.point_count = result.points_mm.length;
+    return result;
+  });
+
+/* ------------------------------------------------------ set_corner_options */
+
+IDC.register('set_corner_options', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcFrameArg(doc, args, 'frame_id');
+    var item = found.item;
+    var type = IDC.itemType(item);
+    var applied, corners;
+
+    if (type === 'line' || type === 'group') {
+      IDC.fail('invalid_state', 'Object ' + args.frame_id + ' is a ' + type + '; corner options need a frame or polygon.', { frame_id: args.frame_id, type: type });
+    }
+    if ((args.corner_type === undefined || args.corner_type === null) && (args.radius_mm === undefined || args.radius_mm === null) && (args.corners === undefined || args.corners === null)) {
+      IDC.fail('invalid_argument', 'Pass corner_type and/or radius_mm for all four corners, or corners {top_left, top_right, bottom_left, bottom_right}.', null);
+    }
+    try {
+      applied = idcApplyCornerArgs(item, args);
+    } catch (e) {
+      if (e && e.isIdcError) { throw e; }
+      IDC.fail('script_error', 'InDesign could not set the corner options of object ' + args.frame_id + ': ' + String(e.message ? e.message : e), { frame_id: args.frame_id });
+    }
+    corners = idcReadCorners(item);
+    if (corners === null) {
+      IDC.fail('invalid_state', 'Object ' + args.frame_id + ' (' + type + ') has no corner options.', { frame_id: args.frame_id, type: type });
+    }
+    if (!applied) { ctx.warn('Nothing to set: every given corner was empty.'); }
+    else { ctx.changes = { modified_frame_ids: [Number(item.id)] }; }
+    return {
+      frame_id: Number(item.id),
+      type: type,
+      corners: { top_left: corners.top_left, top_right: corners.top_right, bottom_left: corners.bottom_left, bottom_right: corners.bottom_right },
+      uniform: corners.uniform,
+      bounds_mm: idcItemBounds(doc, item)
+    };
+  });

package/indesign/commands/42-groups.js

@@ -0,0 +1,117 @@
+/* Wunschliste J Nr. 3 (Sitzung 7) – Gruppen: group_frames, ungroup_frame. */
+
+/* IDs der direkten Mitglieder einer Gruppe. */
+function idcGroupMemberIds(group) {
+  var ids = [];
+  var i, items;
+  try {
+    items = group.pageItems;
+    for (i = 0; i < items.length; i++) { ids.push(Number(items.item(i).id)); }
+  } catch (e) { /* leer */ }
+  return ids;
+}
+
+IDC.register('group_frames', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var ids = args.frame_ids;
+    var items = [];
+    var seen = {};
+    var i, found, item, spread = null, other, group, landing, memberIds;
+
+    if (!IDC.isArray(ids) || ids.length < 2) {
+      IDC.fail('invalid_argument', 'frame_ids must list at least two object ids.', { frame_ids: ids });
+    }
+    if (ids.length > 500) {
+      IDC.fail('invalid_argument', 'frame_ids may list at most 500 objects.', { count: ids.length });
+    }
+    for (i = 0; i < ids.length; i++) {
+      if (typeof ids[i] !== 'number' || Math.floor(ids[i]) !== ids[i]) {
+        IDC.fail('invalid_argument', 'frame_ids must contain whole numbers.', { frame_ids: ids });
+      }
+      if (seen[ids[i]]) {
+        IDC.fail('invalid_argument', 'frame_ids lists object ' + ids[i] + ' twice.', { frame_id: ids[i] });
+      }
+      seen[ids[i]] = true;
+      found = IDC.itemById(doc, ids[i], 'any');
+      if (found === null) {
+        IDC.fail('not_found', 'No object with frame_id ' + ids[i] + ' in this document.', { frame_id: ids[i] });
+      }
+      item = found.item;
+      idcRejectGroupMember(item, ids[i], 'group_frames');
+      idcRejectLocked(doc, item, ids[i], 'group_frames');
+      other = IDC.spreadOfItem(item);
+      if (other === null) {
+        IDC.fail('invalid_state', 'Object ' + ids[i] + ' is not on a spread.', { frame_id: ids[i] });
+      }
+      if (spread === null) { spread = other; }
+      else if (!idcSameObject(spread, other)) {
+        IDC.fail('invalid_state', 'All objects must lie on the same spread (Druckbogen); object ' + ids[i] + ' lies on another one.',
+          { frame_id: ids[i] });
+      }
+      items.push(item);
+    }
+
+    try {
+      group = IDC.concrete(doc.groups.add(items));
+    } catch (e) {
+      IDC.fail('script_error', 'InDesign could not group the objects: ' + String(e.message ? e.message : e), { frame_ids: ids });
+    }
+
+    landing = IDC.landing(group);
+    memberIds = idcGroupMemberIds(group);
+    ctx.changes = { created_frame_ids: [Number(group.id)], modified_frame_ids: memberIds };
+    return {
+      frame_id: Number(group.id),
+      type: 'group',
+      member_ids: memberIds,
+      member_count: memberIds.length,
+      bounds_mm: idcItemBounds(doc, group),
+      landed_on_page_id: landing.page_id,
+      landed_on_page_name: landing.page_name,
+      on_parent_page: IDC.isOnParentSpread(group)
+    };
+  });
+
+IDC.register('ungroup_frame', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcFrameArg(doc, args, 'frame_id');
+    var group = found.item;
+    var memberIds, i, member, landing = null, survivors = [];
+
+    if (IDC.itemType(group) !== 'group') {
+      IDC.fail('invalid_state', 'Object ' + args.frame_id + ' is not a group (it is a ' + IDC.itemType(group) + ').',
+        { frame_id: args.frame_id, type: IDC.itemType(group) });
+    }
+    idcRejectGroupMember(group, args.frame_id, 'ungroup_frame');
+    memberIds = idcGroupMemberIds(group);
+
+    try {
+      group.ungroup();
+    } catch (e) {
+      IDC.fail('script_error', 'InDesign could not ungroup object ' + args.frame_id + ': ' + String(e.message ? e.message : e),
+        { frame_id: args.frame_id });
+    }
+
+    for (i = 0; i < memberIds.length; i++) {
+      member = IDC.itemById(doc, memberIds[i], 'any');
+      if (member !== null) {
+        survivors.push(memberIds[i]);
+        if (landing === null) { landing = IDC.landing(member.item); }
+      }
+    }
+    if (survivors.length !== memberIds.length) {
+      ctx.warn('After ungrouping, ' + (memberIds.length - survivors.length) + ' member id(s) could not be found again; read get_page_state.');
+    }
+    ctx.changes = { removed_frame_ids: [Number(args.frame_id)], modified_frame_ids: survivors };
+    return {
+      frame_id: Number(args.frame_id),
+      member_ids: survivors,
+      member_count: survivors.length,
+      landed_on_page_id: landing === null ? null : landing.page_id,
+      landed_on_page_name: landing === null ? '' : landing.page_name
+    };
+  });