layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/43-layers.js

@@ -0,0 +1,291 @@
+/* Wunschliste J Nr. 2 (Sitzung 8) – Ebenen: list_layers, set_frame_layer, set_layer_visibility. */
+
+function idcReadBool(target, property) {
+  try {
+    var v = target[property];
+    if (v === true || v === false) { return v; }
+    return null;
+  } catch (e) { return null; }
+}
+
+/* Anzahl der Objekte einer Ebene (Dokument- und Musterseiten). */
+function idcLayerItemCount(layer) {
+  try { return Number(layer.pageItems.length); } catch (e) { return null; }
+}
+
+function idcDescribeLayer(layer, index) {
+  var out = {
+    layer_id: null,
+    name: null,
+    index: index,
+    visible: idcReadBool(layer, 'visible'),
+    locked: idcReadBool(layer, 'locked'),
+    printable: idcReadBool(layer, 'printable'),
+    ignore_wrap: idcReadBool(layer, 'ignoreWrap'),
+    show_guides: idcReadBool(layer, 'showGuides'),
+    lock_guides: idcReadBool(layer, 'lockGuides'),
+    item_count: idcLayerItemCount(layer)
+  };
+  try { out.layer_id = Number(layer.id); } catch (e0) { /* null */ }
+  try { out.name = String(layer.name); } catch (e1) { /* null */ }
+  return out;
+}
+
+/* Ebene ueber Name oder ID; genau eines von beiden. Liefert { layer, index }. */
+function idcLayerArg(doc, args) {
+  var hasName = args.layer_name !== undefined && args.layer_name !== null;
+  var hasId = args.layer_id !== undefined && args.layer_id !== null;
+  var i, layer, name;
+  if (hasName && hasId) {
+    IDC.fail('invalid_argument', 'Pass either layer_name or layer_id, not both.', { layer_name: args.layer_name, layer_id: args.layer_id });
+  }
+  if (!hasName && !hasId) {
+    IDC.fail('invalid_argument', 'layer_name or layer_id is required.', null);
+  }
+  if (hasName && (typeof args.layer_name !== 'string' || args.layer_name === '')) {
+    IDC.fail('invalid_argument', 'layer_name must be a non-empty string.', { layer_name: args.layer_name });
+  }
+  for (i = 0; i < doc.layers.length; i++) {
+    layer = doc.layers.item(i);
+    if (hasId) {
+      if (Number(layer.id) === Number(args.layer_id)) { return { layer: layer, index: i }; }
+    } else {
+      try { name = String(layer.name); } catch (e) { name = ''; }
+      if (name === String(args.layer_name)) { return { layer: layer, index: i }; }
+    }
+  }
+  if (hasId) {
+    IDC.fail('not_found', 'No layer with layer_id ' + args.layer_id + ' in this document; see list_layers.', { layer_id: args.layer_id });
+  }
+  IDC.fail('not_found', 'No layer named "' + args.layer_name + '" in this document; see list_layers.', { layer_name: args.layer_name });
+  return null;
+}
+
+/* Ebene eines Objekts, mit Index in doc.layers. */
+function idcLayerOfItem(doc, item) {
+  var layer = null;
+  var i, candidate;
+  try { layer = item.itemLayer; } catch (e0) { layer = null; }
+  if (layer === null || layer === undefined) { return null; }
+  for (i = 0; i < doc.layers.length; i++) {
+    candidate = doc.layers.item(i);
+    if (Number(candidate.id) === Number(layer.id)) { return { layer: candidate, index: i }; }
+  }
+  return { layer: layer, index: null };
+}
+
+/* Kurzform fuer Rueckgaben anderer Werkzeuge: { layer_id, layer_name, visible, locked }. */
+function idcLayerSummary(doc, item) {
+  var found = idcLayerOfItem(doc, item);
+  var out = { layer_id: null, layer_name: null, visible: null, locked: null };
+  if (found === null) { return out; }
+  try { out.layer_id = Number(found.layer.id); } catch (e0) { /* null */ }
+  try { out.layer_name = String(found.layer.name); } catch (e1) { /* null */ }
+  out.visible = idcReadBool(found.layer, 'visible');
+  out.locked = idcReadBool(found.layer, 'locked');
+  return out;
+}
+
+function idcLayerName(item) {
+  try { return String(item.itemLayer.name); } catch (e) { return null; }
+}
+
+/*
+ * Schreibende Werkzeuge: Objekt auf gesperrter Ebene oder selbst gesperrt
+ * -> invalid_state mit klarer Ansage statt eines nackten InDesign-Fehlers.
+ */
+function idcRejectLocked(doc, item, frameId, what) {
+  var layer = idcLayerSummary(doc, item);
+  var itemLocked = idcReadBool(item, 'locked');
+  if (layer.locked === true) {
+    IDC.fail('invalid_state', 'Object ' + frameId + ' lies on the locked layer "' + layer.layer_name + '"; ' + what +
+      ' cannot change it. Unlock the layer with set_layer_visibility (locked false) first.',
+      { frame_id: frameId, layer_id: layer.layer_id, layer_name: layer.layer_name, layer_locked: true, item_locked: itemLocked === true });
+  }
+  if (itemLocked === true) {
+    IDC.fail('invalid_state', 'Object ' + frameId + ' is locked (Objekt > Sperren); ' + what + ' cannot change it.',
+      { frame_id: frameId, layer_id: layer.layer_id, layer_name: layer.layer_name, layer_locked: false, item_locked: true });
+  }
+}
+
+IDC.register('list_layers', { needs_document: true, read_only: true, ruler: 'none' },
+  function (ctx) {
+    var doc = ctx.doc;
+    var out = [];
+    var i, activeId = null, hidden = 0, locked = 0, nonPrinting = 0, entry;
+    for (i = 0; i < doc.layers.length; i++) {
+      entry = idcDescribeLayer(doc.layers.item(i), i);
+      if (entry.visible === false) { hidden += 1; }
+      if (entry.locked === true) { locked += 1; }
+      if (entry.printable === false) { nonPrinting += 1; }
+      out.push(entry);
+    }
+    try { activeId = Number(doc.activeLayer.id); } catch (e0) { activeId = null; }
+    if (nonPrinting > 0) {
+      ctx.warn(nonPrinting + ' layer(s) are set to not print; their objects are missing from PDF exports.');
+    }
+    return {
+      layers: out,
+      count: out.length,
+      active_layer_id: activeId,
+      hidden_count: hidden,
+      locked_count: locked,
+      non_printing_count: nonPrinting
+    };
+  });
+
+IDC.register('set_frame_layer', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcFrameArg(doc, args, 'frame_id');
+    var item = found.item;
+    var createIfMissing = args.create_if_missing === true;
+    var before = idcLayerSummary(doc, item);
+    var target = null;
+    var created = false;
+    var i, layer, name, after, changed;
+
+    idcRejectGroupMember(item, args.frame_id, 'set_frame_layer');
+
+    if (createIfMissing) {
+      if (typeof args.layer_name !== 'string' || args.layer_name === '') {
+        IDC.fail('invalid_argument', 'create_if_missing needs layer_name.', { layer_name: args.layer_name });
+      }
+      if (args.layer_id !== undefined && args.layer_id !== null) {
+        IDC.fail('invalid_argument', 'create_if_missing works with layer_name only, not layer_id.', { layer_id: args.layer_id });
+      }
+      for (i = 0; i < doc.layers.length; i++) {
+        layer = doc.layers.item(i);
+        try { name = String(layer.name); } catch (e0) { name = ''; }
+        if (name === String(args.layer_name)) { target = layer; }
+      }
+      if (target === null) {
+        try {
+          target = doc.layers.add({ name: String(args.layer_name) });
+        } catch (e1) {
+          IDC.fail('script_error', 'InDesign could not create layer "' + args.layer_name + '": ' + String(e1.message ? e1.message : e1),
+            { layer_name: args.layer_name });
+        }
+        created = true;
+        ctx.warn('Layer "' + args.layer_name + '" did not exist and was created (on top).');
+      }
+    } else {
+      target = idcLayerArg(doc, args).layer;
+    }
+
+    if (before.layer_id !== null && Number(target.id) === before.layer_id) {
+      return {
+        frame_id: Number(item.id),
+        type: IDC.itemType(item),
+        layer_id: before.layer_id,
+        layer_name: before.layer_name,
+        previous_layer_id: before.layer_id,
+        previous_layer_name: before.layer_name,
+        layer_created: created,
+        changed: false
+      };
+    }
+
+    if (idcReadBool(target, 'locked') === true) {
+      IDC.fail('invalid_state', 'Target layer "' + String(target.name) + '" is locked; unlock it with set_layer_visibility first.',
+        { layer_id: Number(target.id), layer_name: String(target.name) });
+    }
+
+    try {
+      item.itemLayer = target;
+    } catch (e2) {
+      IDC.fail('script_error', 'InDesign could not move object ' + args.frame_id + ' to layer "' + String(target.name) + '": ' + String(e2.message ? e2.message : e2),
+        { frame_id: args.frame_id, layer_name: String(target.name) });
+    }
+
+    after = idcLayerSummary(doc, item);
+    changed = after.layer_id !== before.layer_id;
+    if (!changed) {
+      ctx.warn('InDesign reports the object still on layer "' + after.layer_name + '" after the move.');
+    }
+    if (after.visible === false) {
+      ctx.warn('Layer "' + after.layer_name + '" is hidden; the object is now invisible.');
+    }
+    ctx.changes = { modified_frame_ids: [Number(item.id)] };
+    return {
+      frame_id: Number(item.id),
+      type: IDC.itemType(item),
+      layer_id: after.layer_id,
+      layer_name: after.layer_name,
+      previous_layer_id: before.layer_id,
+      previous_layer_name: before.layer_name,
+      layer_created: created,
+      changed: changed
+    };
+  });
+
+IDC.register('set_layer_visibility', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcLayerArg(doc, args);
+    var layer = found.layer;
+    var fields = ['visible', 'locked', 'printable'];
+    var previous = {};
+    var wanted = {};
+    var given = 0;
+    var i, key, value, after, changed = false;
+
+    for (i = 0; i < fields.length; i++) {
+      key = fields[i];
+      value = args[key];
+      if (value === undefined || value === null) { continue; }
+      if (value !== true && value !== false) {
+        IDC.fail('invalid_argument', key + ' must be true or false.', { field: key, value: value });
+      }
+      wanted[key] = value;
+      given += 1;
+    }
+    if (given === 0) {
+      IDC.fail('invalid_argument', 'Pass at least one of visible, locked, printable.', null);
+    }
+
+    for (i = 0; i < fields.length; i++) {
+      previous[fields[i]] = idcReadBool(layer, fields[i]);
+    }
+
+    for (i = 0; i < fields.length; i++) {
+      key = fields[i];
+      if (!IDC.hasOwn(wanted, key)) { continue; }
+      if (previous[key] === wanted[key]) { continue; }
+      try {
+        layer[key] = wanted[key];
+      } catch (e0) {
+        IDC.fail('script_error', 'InDesign could not set ' + key + ' on layer "' + String(layer.name) + '": ' + String(e0.message ? e0.message : e0),
+          { layer_id: Number(layer.id), layer_name: String(layer.name), field: key });
+      }
+      changed = true;
+    }
+
+    after = idcDescribeLayer(layer, found.index);
+    for (i = 0; i < fields.length; i++) {
+      key = fields[i];
+      if (IDC.hasOwn(wanted, key) && after[key] !== wanted[key]) {
+        ctx.warn('InDesign reports ' + key + ' = ' + String(after[key]) + ' on layer "' + after.name + '" after the change.');
+      }
+    }
+    if (after.visible === false && after.item_count > 0) {
+      ctx.warn('Layer "' + after.name + '" is hidden with ' + after.item_count + ' object(s) on it.');
+    }
+    if (after.printable === false) {
+      ctx.warn('Layer "' + after.name + '" does not print; its objects are missing from PDF exports.');
+    }
+    if (changed) { ctx.changes = { modified_layer_ids: [after.layer_id] }; }
+    return {
+      layer_id: after.layer_id,
+      name: after.name,
+      index: after.index,
+      visible: after.visible,
+      locked: after.locked,
+      printable: after.printable,
+      item_count: after.item_count,
+      previous: previous,
+      changed: changed
+    };
+  });

package/indesign/commands/44-effects.js

@@ -0,0 +1,274 @@
+/*
+ * Auftrag A-8.6 (Sitzung 9) – set_frame_effects: Deckkraft, Mischmodus,
+ * Schlagschatten und weiche Kante eines Objekts (InDesign "Effekte"),
+ * getrennt fuer Objekt, Flaeche, Kontur und Text. Adobe-DOM (Auftrag,
+ * geprueft 05.09.2026): transparencySettings, fillTransparencySettings,
+ * strokeTransparencySettings, contentTransparencySettings ->
+ * TransparencySetting {blendingSettings {opacity, blendMode},
+ * dropShadowSettings {mode, opacity, angle, distance, size, spread, noise,
+ * effectColor, blendMode, xOffset, yOffset, useGlobalLight, knockedOut,
+ * honorOtherEffects}, featherSettings {mode, width, cornerType, noise,
+ * chokeAmount}}. Werte von FeatherCornerType nicht belegbar (404) – live
+ * bestaetigt (Journal). Masse (distance, size, width, xOffset, yOffset)
+ * laufen ueber die Millimeter-Klammer des Interpreters.
+ */
+
+var IDC_BLEND_MODES = [
+  ['normal', 'NORMAL'], ['multiply', 'MULTIPLY'], ['screen', 'SCREEN'], ['overlay', 'OVERLAY'],
+  ['soft_light', 'SOFT_LIGHT'], ['hard_light', 'HARD_LIGHT'], ['color_dodge', 'COLOR_DODGE'],
+  ['color_burn', 'COLOR_BURN'], ['darken', 'DARKEN'], ['lighten', 'LIGHTEN'], ['difference', 'DIFFERENCE'],
+  ['exclusion', 'EXCLUSION'], ['hue', 'HUE'], ['saturation', 'SATURATION'], ['color', 'COLOR'], ['luminosity', 'LUMINOSITY']
+];
+
+var IDC_FEATHER_CORNERS = [['sharp', 'SHARP'], ['rounded', 'ROUNDED'], ['diffused', 'DIFFUSION']];
+
+var IDC_EFFECT_TARGETS = {
+  object: 'transparencySettings',
+  fill: 'fillTransparencySettings',
+  stroke: 'strokeTransparencySettings',
+  text: 'contentTransparencySettings'
+};
+
+function idcEnumByTable(table, enumObject, enumName, value, field) {
+  var i;
+  if (typeof enumObject === 'undefined') {
+    IDC.fail('invalid_state', 'This runtime has no ' + enumName + ' enumeration.', null);
+  }
+  for (i = 0; i < table.length; i++) {
+    if (table[i][0] === value) {
+      if (enumObject[table[i][1]] === undefined) {
+        IDC.fail('invalid_state', 'This InDesign version has no ' + enumName + '.' + table[i][1] + '.', { value: value });
+      }
+      return enumObject[table[i][1]];
+    }
+  }
+  IDC.fail('invalid_argument', field + ' must be one of: ' + idcCompEnumNames(table) + '.', { value: value });
+  return null;
+}
+
+function idcEnumNameByTable(table, enumObject, value) {
+  var i;
+  if (value === null || value === undefined || typeof enumObject === 'undefined') { return null; }
+  for (i = 0; i < table.length; i++) {
+    try {
+      if (enumObject[table[i][1]] !== undefined && IDC.enumIs(value, enumObject[table[i][1]])) { return table[i][0]; }
+    } catch (e) { /* weiter */ }
+  }
+  return String(value);
+}
+
+function idcEffectPercent(spec, key, field) {
+  return idcOptNumber(spec, key, field, 0, 100, false);
+}
+
+/* Effekte eines Zielbereichs lesen. */
+function idcReadEffects(settings) {
+  var out = {
+    opacity_percent: null,
+    blend_mode: null,
+    drop_shadow: { enabled: null, opacity_percent: null, angle_deg: null, distance_mm: null, size_mm: null, spread_percent: null, noise_percent: null, color: null, blend_mode: null, use_global_light: null, knocked_out: null, honor_other_effects: null, x_offset_mm: null, y_offset_mm: null },
+    feather: { enabled: null, width_mm: null, corner_type: null, noise_percent: null, choke_percent: null }
+  };
+  var b = null, d = null, f = null;
+  if (settings === null || settings === undefined) { return out; }
+  try { b = settings.blendingSettings; } catch (e0) { b = null; }
+  try { d = settings.dropShadowSettings; } catch (e1) { d = null; }
+  try { f = settings.featherSettings; } catch (e2) { f = null; }
+  if (b !== null) {
+    try { out.opacity_percent = IDC.round(Number(b.opacity), 3); } catch (e3) { /* null */ }
+    try { out.blend_mode = idcEnumNameByTable(IDC_BLEND_MODES, typeof BlendMode === 'undefined' ? undefined : BlendMode, b.blendMode); } catch (e4) { /* null */ }
+  }
+  if (d !== null) {
+    try { out.drop_shadow.enabled = typeof ShadowMode !== 'undefined' && IDC.enumIs(d.mode, ShadowMode.DROP); } catch (e5) { /* null */ }
+    try { out.drop_shadow.opacity_percent = IDC.round(Number(d.opacity), 3); } catch (e6) { /* null */ }
+    try { out.drop_shadow.angle_deg = IDC.round(Number(d.angle), 3); } catch (e7) { /* null */ }
+    try { out.drop_shadow.distance_mm = IDC.round(Number(d.distance), 3); } catch (e8) { /* null */ }
+    try { out.drop_shadow.size_mm = IDC.round(Number(d.size), 3); } catch (e9) { /* null */ }
+    try { out.drop_shadow.spread_percent = IDC.round(Number(d.spread), 3); } catch (e10) { /* null */ }
+    try { out.drop_shadow.noise_percent = IDC.round(Number(d.noise), 3); } catch (e11) { /* null */ }
+    try { out.drop_shadow.color = String(d.effectColor.name); } catch (e12) { /* null */ }
+    try { out.drop_shadow.blend_mode = idcEnumNameByTable(IDC_BLEND_MODES, typeof BlendMode === 'undefined' ? undefined : BlendMode, d.blendMode); } catch (e13) { /* null */ }
+    try { out.drop_shadow.use_global_light = d.useGlobalLight === true; } catch (e14) { /* null */ }
+    try { out.drop_shadow.knocked_out = d.knockedOut === true; } catch (e15) { /* null */ }
+    try { out.drop_shadow.honor_other_effects = d.honorOtherEffects === true; } catch (e16) { /* null */ }
+    try { out.drop_shadow.x_offset_mm = IDC.round(Number(d.xOffset), 3); } catch (e17) { /* null */ }
+    try { out.drop_shadow.y_offset_mm = IDC.round(Number(d.yOffset), 3); } catch (e18) { /* null */ }
+  }
+  if (f !== null) {
+    try { out.feather.enabled = typeof FeatherMode !== 'undefined' && IDC.enumIs(f.mode, FeatherMode.STANDARD); } catch (e19) { /* null */ }
+    try { out.feather.width_mm = IDC.round(Number(f.width), 3); } catch (e20) { /* null */ }
+    try { out.feather.corner_type = idcEnumNameByTable(IDC_FEATHER_CORNERS, typeof FeatherCornerType === 'undefined' ? undefined : FeatherCornerType, f.cornerType); } catch (e21) { /* null */ }
+    try { out.feather.noise_percent = IDC.round(Number(f.noise), 3); } catch (e22) { /* null */ }
+    try { out.feather.choke_percent = IDC.round(Number(f.chokeAmount), 3); } catch (e23) { /* null */ }
+  }
+  return out;
+}
+
+/* Weicht ein Zielbereich vom Normalzustand ab (Deckkraft 100, normal, kein Schatten, keine Kante)? */
+function idcHasEffects(settings) {
+  var e = idcReadEffects(settings);
+  if (e.opacity_percent !== null && e.opacity_percent < 100) { return true; }
+  if (e.blend_mode !== null && e.blend_mode !== 'normal') { return true; }
+  if (e.drop_shadow.enabled === true) { return true; }
+  if (e.feather.enabled === true) { return true; }
+  return false;
+}
+
+function idcEffectSettings(item, target) {
+  var property = IDC_EFFECT_TARGETS[target];
+  var settings = null;
+  try { settings = item[property]; } catch (e) { settings = null; }
+  return settings === undefined ? null : settings;
+}
+
+/* Objekt-Effekte fuer get_frame_options: effects (object) und has_effects {fill, stroke, text}. */
+function idcEffectsSummary(item) {
+  var out = { effects: idcReadEffects(idcEffectSettings(item, 'object')), has_effects: { fill: null, stroke: null, text: null } };
+  var s;
+  s = idcEffectSettings(item, 'fill');
+  if (s !== null) { out.has_effects.fill = idcHasEffects(s); }
+  s = idcEffectSettings(item, 'stroke');
+  if (s !== null) { out.has_effects.stroke = idcHasEffects(s); }
+  if (IDC.isTextFrame(item)) {
+    s = idcEffectSettings(item, 'text');
+    if (s !== null) { out.has_effects.text = idcHasEffects(s); }
+  }
+  return out;
+}
+
+var IDC_SHADOW_KEYS = { enabled: 1, opacity_percent: 1, angle_deg: 1, distance_mm: 1, size_mm: 1, spread_percent: 1, noise_percent: 1, color: 1, blend_mode: 1, use_global_light: 1, knocked_out: 1, honor_other_effects: 1 };
+var IDC_FEATHER_KEYS = { enabled: 1, width_mm: 1, corner_type: 1, noise_percent: 1, choke_percent: 1 };
+
+function idcRejectUnknownKeys(spec, allowed, field) {
+  var key;
+  for (key in spec) {
+    if (IDC.hasOwn(spec, key) && !IDC.hasOwn(allowed, key)) {
+      IDC.fail('invalid_argument', field + '.' + key + ' is not supported in this version (only ' + idcKeysOf(allowed) + ').', { key: key });
+    }
+  }
+}
+
+function idcKeysOf(obj) {
+  var out = [], k;
+  for (k in obj) { if (IDC.hasOwn(obj, k)) { out.push(k); } }
+  return out.join(', ');
+}
+
+IDC.register('set_frame_effects', { needs_document: true, read_only: false, ruler: 'none' },
+  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 target = idcGiven(args.target) ? String(args.target) : 'object';
+    var settings, blending, shadow, feather, changed = [], spec, v, color;
+
+    if (!IDC.hasOwn(IDC_EFFECT_TARGETS, target)) {
+      IDC.fail('invalid_argument', 'target must be object, fill, stroke or text.', { target: target });
+    }
+    if (target === 'text' && !IDC.isTextFrame(item)) {
+      IDC.fail('invalid_state', 'target "text" needs a text frame; object ' + args.frame_id + ' is a ' + type + '.', { frame_id: args.frame_id, type: type });
+    }
+    if (!idcGiven(args.opacity_percent) && !idcGiven(args.blend_mode) && !idcGiven(args.drop_shadow) && !idcGiven(args.feather)) {
+      IDC.fail('invalid_argument', 'Pass at least one of opacity_percent, blend_mode, drop_shadow or feather.', null);
+    }
+    settings = idcEffectSettings(item, target);
+    if (settings === null) {
+      IDC.fail('invalid_state', 'Object ' + args.frame_id + ' has no ' + IDC_EFFECT_TARGETS[target] + ' in this runtime.', { frame_id: args.frame_id, target: target });
+    }
+
+    /* Erst alles pruefen, dann schreiben. */
+    var opacity = idcOptNumber(args, 'opacity_percent', 'set_frame_effects', 0, 100, false);
+    var blendMode = idcGiven(args.blend_mode) ? idcEnumByTable(IDC_BLEND_MODES, typeof BlendMode === 'undefined' ? undefined : BlendMode, 'BlendMode', String(args.blend_mode), 'blend_mode') : null;
+    var shadowSpec = null, featherSpec = null;
+    if (idcGiven(args.drop_shadow)) {
+      spec = idcObjectArg(args.drop_shadow, 'drop_shadow');
+      idcRejectUnknownKeys(spec, IDC_SHADOW_KEYS, 'drop_shadow');
+      if (typeof spec.enabled !== 'boolean') { IDC.fail('invalid_argument', 'drop_shadow.enabled (true/false) is required.', { value: spec.enabled }); }
+      shadowSpec = {
+        enabled: spec.enabled,
+        opacity: idcEffectPercent(spec, 'opacity_percent', 'drop_shadow'),
+        angle: idcOptNumber(spec, 'angle_deg', 'drop_shadow', -360, 360, false),
+        distance: idcOptNumber(spec, 'distance_mm', 'drop_shadow', 0, 352.778, false),
+        size: idcOptNumber(spec, 'size_mm', 'drop_shadow', 0, 50.08, false),
+        spread: idcEffectPercent(spec, 'spread_percent', 'drop_shadow'),
+        noise: idcEffectPercent(spec, 'noise_percent', 'drop_shadow'),
+        blendMode: idcGiven(spec.blend_mode) ? idcEnumByTable(IDC_BLEND_MODES, typeof BlendMode === 'undefined' ? undefined : BlendMode, 'BlendMode', String(spec.blend_mode), 'drop_shadow.blend_mode') : null,
+        useGlobalLight: idcOptBool(spec, 'use_global_light', 'drop_shadow'),
+        knockedOut: idcOptBool(spec, 'knocked_out', 'drop_shadow'),
+        honorOtherEffects: idcOptBool(spec, 'honor_other_effects', 'drop_shadow'),
+        color: null
+      };
+      if (idcGiven(spec.color)) {
+        color = idcObjectArg(spec.color, 'drop_shadow.color');
+        idcBothGiven(color, 'swatch_name', 'hex');
+        if (idcGiven(color.swatch_name)) { shadowSpec.color = idcSwatchArg(doc, color.swatch_name, 'drop_shadow.color.swatch_name'); }
+        else if (idcGiven(color.hex)) { shadowSpec.color = idcSwatchForHex(doc, color.hex, 'drop_shadow.color.hex', []); }
+        else { IDC.fail('invalid_argument', 'drop_shadow.color needs swatch_name or hex.', { value: color }); }
+      }
+    }
+    if (idcGiven(args.feather)) {
+      spec = idcObjectArg(args.feather, 'feather');
+      idcRejectUnknownKeys(spec, IDC_FEATHER_KEYS, 'feather');
+      if (typeof spec.enabled !== 'boolean') { IDC.fail('invalid_argument', 'feather.enabled (true/false) is required.', { value: spec.enabled }); }
+      featherSpec = {
+        enabled: spec.enabled,
+        width: idcOptNumber(spec, 'width_mm', 'feather', 0, 352.78, false),
+        cornerType: idcGiven(spec.corner_type) ? idcEnumByTable(IDC_FEATHER_CORNERS, typeof FeatherCornerType === 'undefined' ? undefined : FeatherCornerType, 'FeatherCornerType', String(spec.corner_type), 'feather.corner_type') : null,
+        noise: idcEffectPercent(spec, 'noise_percent', 'feather'),
+        choke: idcEffectPercent(spec, 'choke_percent', 'feather')
+      };
+    }
+
+    try {
+      if (opacity !== null || blendMode !== null) {
+        blending = settings.blendingSettings;
+        if (opacity !== null) { blending.opacity = opacity; changed.push('opacity_percent'); }
+        if (blendMode !== null) { blending.blendMode = blendMode; changed.push('blend_mode'); }
+      }
+      if (shadowSpec !== null) {
+        shadow = settings.dropShadowSettings;
+        if (typeof ShadowMode === 'undefined') { IDC.fail('invalid_state', 'This runtime has no ShadowMode enumeration.', null); }
+        shadow.mode = shadowSpec.enabled ? ShadowMode.DROP : ShadowMode.NONE;
+        if (shadowSpec.enabled) {
+          if (shadowSpec.opacity !== null) { shadow.opacity = shadowSpec.opacity; }
+          if (shadowSpec.angle !== null) { shadow.angle = shadowSpec.angle; }
+          if (shadowSpec.distance !== null) { shadow.distance = shadowSpec.distance; }
+          if (shadowSpec.size !== null) { shadow.size = shadowSpec.size; }
+          if (shadowSpec.spread !== null) { shadow.spread = shadowSpec.spread; }
+          if (shadowSpec.noise !== null) { shadow.noise = shadowSpec.noise; }
+          if (shadowSpec.color !== null) { shadow.effectColor = shadowSpec.color; }
+          if (shadowSpec.blendMode !== null) { shadow.blendMode = shadowSpec.blendMode; }
+          if (shadowSpec.useGlobalLight !== null) { shadow.useGlobalLight = shadowSpec.useGlobalLight; }
+          if (shadowSpec.knockedOut !== null) { shadow.knockedOut = shadowSpec.knockedOut; }
+          if (shadowSpec.honorOtherEffects !== null) { shadow.honorOtherEffects = shadowSpec.honorOtherEffects; }
+        }
+        changed.push('drop_shadow');
+      }
+      if (featherSpec !== null) {
+        feather = settings.featherSettings;
+        if (typeof FeatherMode === 'undefined') { IDC.fail('invalid_state', 'This runtime has no FeatherMode enumeration.', null); }
+        feather.mode = featherSpec.enabled ? FeatherMode.STANDARD : FeatherMode.NONE;
+        if (featherSpec.enabled) {
+          if (featherSpec.width !== null) { feather.width = featherSpec.width; }
+          if (featherSpec.cornerType !== null) { feather.cornerType = featherSpec.cornerType; }
+          if (featherSpec.noise !== null) { feather.noise = featherSpec.noise; }
+          if (featherSpec.choke !== null) { feather.chokeAmount = featherSpec.choke; }
+        }
+        changed.push('feather');
+      }
+    } catch (e) {
+      if (e && e.isIdcError) { throw e; }
+      IDC.fail('script_error', 'InDesign could not set the effects of object ' + args.frame_id + ' (' + target + '): ' + String(e.message ? e.message : e), { frame_id: args.frame_id, target: target });
+    }
+
+    ctx.changes = { modified_frame_ids: [Number(item.id)] };
+    return {
+      frame_id: Number(item.id),
+      type: type,
+      target: target,
+      effects: idcReadEffects(settings),
+      changed: changed
+    };
+  });