@adobe/helix-md2jcr 1.2.21 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/helix-md2jcr",
-  "version": "1.2.21",
+  "version": "1.4.1",
   "description": "Helix Service that converts markdown to JCR content structure",
   "main": "src/index.js",
   "type": "module",
@@ -74,12 +74,12 @@
     "husky": "^9.1.7",
     "junit-report-builder": "5.1.2",
     "lint-staged": "16.4.0",
-    "mocha": "11.7.5",
+    "mocha": "11.7.6",
     "mocha-multi-reporters": "1.5.1",
     "nock": "13.5.6",
     "semantic-release": "25.0.3",
     "unist-util-inspect": "8.1.0",
-    "yauzl": "3.3.0"
+    "yauzl": "3.3.1"
   },
   "lint-staged": {
     "*.js": "eslint"

package/src/mdast2jcr/domain/FieldGroup.js

@@ -9,6 +9,8 @@
  * OF ANY KIND, either express or implied. See the License for the specific language
  * governing permissions and limitations under the License.
  */
+import { isClassesField } from './Models.js';
+
 class FieldGroup {
   /**
    * Constructor.
@@ -35,7 +37,7 @@ class FieldGroup {
 
     this.model.fields
       .filter((field) => field.component !== 'tab')
-      .filter((field) => field.name !== 'classes')
+      .filter((field) => !isClassesField(field.name))
       .forEach((field) => {
         if (field.name.includes('_')) {
           const groupName = field.name.split('_')[0];

package/src/mdast2jcr/domain/GroupOptions.js

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { isGroupField } from './Models.js';
+
+/**
+ * @typedef {import('../index.d.ts').ModelDef} Model
+ */
+
+/**
+ * Recursively collect every option `value` from a field's options tree
+ * (options may be nested under `children`).
+ * @param {Array<object>} options - The field's options array.
+ * @return {Array<string>} The flat list of option values.
+ */
+function collectOptionValues(options) {
+  return (options || []).flatMap((option) => {
+    if (option.children) {
+      return collectOptionValues(option.children);
+    }
+    return option.value !== undefined ? [option.value] : [];
+  });
+}
+
+/**
+ * Distribute element-grouping tokens (a block header's classes, a container
+ * child's leading cell, or a section's `style` cell) across the model's group
+ * fields, per the AEM "element grouping for block options" rules:
+ *
+ * - a boolean field receives "true" when its name suffix (after `${group}_`)
+ *   appears as a token (e.g. token "fullwidth" -> `${group}_fullwidth`="true");
+ * - a text/select field with options claims the tokens that match its option
+ *   values (e.g. token "light" -> `${group}_background`="light");
+ * - any remaining tokens fall back to the base `${group}` field, which also
+ *   covers the common single-field case (a free-form `${group}` field).
+ *
+ * Multi fields are written as `[a, b]`; single fields as a comma-separated list.
+ * The result is emitted in model-field order so callers that do not sort
+ * (e.g. sections) get deterministic, readable output.
+ * @param {Model} model - The block, item, or section model.
+ * @param {Array<string>} tokens - The option tokens.
+ * @param {string} [group] - The group name (defaults to `classes`).
+ * @return {Object<string, string>} A map of group field name to property value.
+ */
+function distributeGroupOptions(model, tokens, group = 'classes') {
+  const groupFields = (model?.fields || []).filter((f) => isGroupField(f.name, group));
+  if (groupFields.length === 0 || tokens.length === 0) {
+    return {};
+  }
+
+  const suffixRegExp = new RegExp(`^${group}_`);
+  const remaining = [...tokens];
+  const assigned = new Map();
+
+  // boolean fields: the suffix after `${group}_` becomes the option when present
+  groupFields
+    .filter((field) => field.component === 'boolean')
+    .forEach((field) => {
+      const suffix = field.name.replace(suffixRegExp, '');
+      const idx = remaining.indexOf(suffix);
+      if (idx !== -1) {
+        assigned.set(field.name, true);
+        remaining.splice(idx, 1);
+      }
+    });
+
+  // text/select fields with options: claim the tokens that match their values
+  groupFields
+    .filter((field) => field.component !== 'boolean' && field.options)
+    .forEach((field) => {
+      const values = collectOptionValues(field.options);
+      const matched = remaining.filter((t) => values.includes(t));
+      if (matched.length > 0) {
+        assigned.set(field.name, matched);
+        matched.forEach((m) => remaining.splice(remaining.indexOf(m), 1));
+      }
+    });
+
+  // leftover tokens fall back to the base `${group}` field (and the single-field case)
+  const base = groupFields.find((f) => f.name === group && f.component !== 'boolean');
+  if (remaining.length > 0 && base) {
+    assigned.set(group, [...(assigned.get(group) || []), ...remaining]);
+  }
+
+  // emit in model-field order for deterministic, readable output
+  const result = {};
+  groupFields.forEach((field) => {
+    if (!assigned.has(field.name)) {
+      return;
+    }
+    const value = assigned.get(field.name);
+    if (value === true) {
+      result[field.name] = 'true';
+    } else {
+      result[field.name] = field.multi === true ? `[${value.join(', ')}]` : value.join(', ');
+    }
+  });
+  return result;
+}
+
+export {
+  collectOptionValues,
+  distributeGroupOptions,
+};

package/src/mdast2jcr/domain/Models.js

@@ -42,7 +42,33 @@ function getField(model, fieldName) {
 }
 
 /**
- * Return a list of field names in the model, excluding 'classes'.
+ * Returns true if the field name belongs to an element-grouping group — either
+ * the base field named exactly `group`, or a grouped option field `group_<name>`
+ * (element grouping for block options / section styles).
+ * @param {string} name The field name.
+ * @param {string} group The group name (e.g. `classes` or `style`).
+ * @return {boolean}
+ */
+function isGroupField(name, group) {
+  return name === group || name.startsWith(`${group}_`);
+}
+
+/**
+ * Returns true if the field name belongs to the `classes` block-options group —
+ * either the base `classes` field or a grouped `classes_*` option field
+ * (element grouping for block options).
+ * @param {string} name The field name.
+ * @return {boolean}
+ */
+function isClassesField(name) {
+  return isGroupField(name, 'classes');
+}
+
+/**
+ * Return a list of field names in the model. Block-option / section-style group
+ * fields (`classes`, `classes_*`, `style`, `style_*`) are included so the
+ * Universal Editor can render their controls; only `tab` fields (a UE layout
+ * construct, not a content field) are excluded.
  * @param {Model} model The model.
  * @return {Array<string>} An array of field names.
  */
@@ -51,7 +77,6 @@ function getModelFieldNames(model) {
     ? model.fields
       .filter((f) => f.component !== 'tab')
       .map((f) => f.name)
-      .filter((f) => f !== 'classes')
     : [];
 }
 
@@ -59,4 +84,6 @@ export {
   getField,
   findModelById,
   getModelFieldNames,
+  isClassesField,
+  isGroupField,
 };

package/src/mdast2jcr/hb/helpers/section-helper.js

@@ -18,6 +18,7 @@ import {
   getField,
   getModelFieldNames,
 } from '../../domain/Models.js';
+import { distributeGroupOptions } from '../../domain/GroupOptions.js';
 
 /**
  * Normalizes strings by converting to lowercase and replacing spaces with hyphens
@@ -61,6 +62,12 @@ function processMetadataRows(rows, model) {
   // always push the model fields so UE can use them, even if no attributes are found
   const modelFields = getModelFieldNames(model);
 
+  // a section uses element grouping when it declares a `style_*` field; in that
+  // case the single well-known `style` cell collapses the whole style group and
+  // must be distributed back across style / style_* fields. A model with only a
+  // base `style` field keeps the simple per-row mapping below.
+  const hasStyleGroup = (model?.fields || []).some((f) => f.name.startsWith('style_'));
+
   for (const row of rows) {
     const cells = findAll(row, (n) => n.type === 'gtCell', true);
     if (cells.length < 2) {
@@ -77,6 +84,22 @@ function processMetadataRows(rows, model) {
       continue;
     }
 
+    // element grouping for section styles: route the flat `style` cell across
+    // the model's style group fields (boolean by name suffix, select/multiselect
+    // by declared options, leftovers to the base `style` field)
+    if (hasStyleGroup && key === 'style') {
+      Object.assign(
+        attributes,
+        distributeGroupOptions(
+          model,
+          value.split(',').map((s) => s.trim()).filter(Boolean),
+          'style',
+        ),
+      );
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
     const field = getField(model, key);
     if (!field) {
       // eslint-disable-next-line no-continue

package/src/mdast2jcr/hb/partials/grid-table.js

@@ -19,8 +19,9 @@ import { toHtml } from 'hast-util-to-html';
 import { getComponentById, getComponentByTitle, getModelId } from '../../domain/Definitions.js';
 import {
   findModelById,
-  getField, getModelFieldNames,
+  getModelFieldNames, isClassesField,
 } from '../../domain/Models.js';
+import { distributeGroupOptions } from '../../domain/GroupOptions.js';
 import { findAll } from '../../utils/mdast.js';
 import link from './supports/link.js';
 import {
@@ -105,14 +106,10 @@ function extractBlockHeaderProperties(models, definition, mdast) {
 
   const model = findModelById(models, blockDetails.modelId);
 
-  // section metadata may not have a model
+  // section metadata may not have a model. Distribute the header's block options
+  // across the model's classes group fields (element grouping for block options).
   if (model) {
-    const classesField = getField(model, 'classes');
-
-    if (blockDetails.classes.length > 0 && classesField) {
-      props.classes = (classesField.multi === true)
-        ? `[${blockDetails.classes.join(', ')}]` : blockDetails.classes.join(', ');
-    }
+    Object.assign(props, distributeGroupOptions(model, blockDetails.classes, 'classes'));
   }
 
   return props;
@@ -353,14 +350,10 @@ function extractProperties(
 
   // the first cells is the header row, so we skip it
   const rows = findAll(mdast, (node) => node.type === 'gtRow', false);
-  let classesField;
   if (mode === 'blockItem') {
-    classesField = getField(model, 'classes');
-    // if our model defines a classes field then dig out the classes from the first cell
-    if (classesField) {
-      // if we are a block item we need to look at the first cell to see if it has any class
-      // properties by inspecting the text value for any commas
-      // if there is a comma that then becomes the classes property for the block item
+    // if our model defines any classes group field then dig the block options out
+    // of the first cell (the component id followed by optional class names)
+    if ((model.fields || []).some((f) => isClassesField(f.name))) {
       const firstCell = rows[0].children[0];
       const textValue = toString(firstCell);
       const classes = textValue.split(',').map((c) => c.trim());
@@ -368,11 +361,8 @@ function extractProperties(
       // discard the component name leaving only the block option names (class names)
       classes.shift();
 
-      // if we are left with any classes to add to the block item, then add them
-      if (classes.length > 0) {
-        properties.classes = classesField?.multi === true
-          ? `[${classes.join(', ')}]` : classes.join(', ');
-      }
+      // distribute the options across the model's classes group fields
+      Object.assign(properties, distributeGroupOptions(model, classes, 'classes'));
     }
   } else {
     // get rid of the header row, no need for that