@adobe/helix-md2jcr 1.0.0

package/src/mdast2jcr/mdast-sanitize-html.js

@@ -0,0 +1,233 @@
+/*
+ * Copyright 2020 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 { visit } from 'unist-util-visit';
+import { unified } from 'unified';
+import parse from 'rehype-parse';
+import { defaultHandlers, toMdast } from 'hast-util-to-mdast';
+import tableHandler from './hast-table-handler.js';
+import tableCellHandler from './hast-table-cell-handler.js';
+
+/**
+ * Creates simple format handler
+ * @param type
+ */
+function formatHandler(type) {
+  return (state, node) => {
+    const result = { type, children: state.all(node) };
+    state.patch(node, result);
+    return result;
+  };
+}
+
+/**
+ * @param {State} state
+ *   State.
+ * @param {Readonly<Element>} node
+ *   hast element to transform.
+ * @returns {Link}
+ *   mdast node.
+ */
+export function linkHandler(state, node) {
+  const properties = node.properties || {};
+  // Allow potentially “invalid” nodes, they might be unknown.
+  // We also support straddling later.
+  const children = /** @type {Array<PhrasingContent>} */ (state.all(node));
+
+  /** @type {Link} */
+  const result = {
+    type: 'link',
+    url: state.resolve(String(properties.href || '') || null),
+    title: properties.title ? String(properties.title) : null,
+    anchor: properties.name ?? properties.id,
+
+    // if the link has a child of type link, then we need to unwrap it
+    children: children.length === 1 && children[0].type === 'link' ? children[0].children : children,
+  };
+  state.patch(node, result);
+  return result;
+}
+
+/**
+ * removes paragraphs from the child nodes recursively.
+ * @param  node
+ */
+function unwrapParagraphs(node) {
+  if (!node.children) {
+    return node;
+  }
+  for (let idx = 0; idx < node.children.length; idx += 1) {
+    const child = node.children[idx];
+    if (child.type === 'paragraph') {
+      node.children.splice(idx, 1, ...child.children);
+      idx += child.children.length - 1;
+    } else {
+      // eslint-disable-next-line no-param-reassign
+      node.children[idx] = unwrapParagraphs(child);
+    }
+  }
+  return node;
+}
+
+/**
+ * Handler for `<markdown>` elements.
+ * @param {[]} mdasts array of mdast sub trees
+ */
+function mdHandler(mdasts) {
+  return (state, node) => {
+    // given the index property from the <markdown idx> element, return the
+    // corresponding mdast sub tree from the mdasts array.
+    const { idx } = node.properties;
+    return mdasts[+idx];
+  };
+}
+
+function isPhrasingParent(node) {
+  return [
+    'paragraph',
+    'underline',
+    'subscript',
+    'superscript',
+    'heading',
+    'emphasis',
+    'strong',
+    'link',
+    'linkReference',
+    'tableCell',
+    'delete',
+    'footnote',
+  ].includes(node.type);
+}
+
+/**
+ * Find the index of the last HTML node in the list of siblings, if no HTML node
+ * is found, return an index of 0;
+ * @param siblings list of siblings to search through to find the last HTML node
+ * @returns {number}
+ */
+export function locateIndexOfLastHtmlNode(siblings) {
+  const index = [...siblings]
+    .reverse()
+    .findIndex((sibling) => sibling.type === 'html');
+
+  // restore the order of the siblings array before returning the index
+  return index === -1 ? 0 : siblings.length - index - 1;
+}
+
+/**
+ * Sanitizes html:
+ * - collapses consecutive html content (simply concat all nodes until the last html sibling)
+ * - parses and converts them to mdast again
+ *
+ * @param {object} tree
+ * @returns {object} The modified (original) tree.
+ */
+export default function sanitizeHtml(tree) {
+  const mdInserts = [];
+
+  visit(tree, (node, index, parent) => {
+    const { children: siblings = [] } = parent || {};
+
+    // collapse html blocks
+    if (node.type === 'html') {
+      // find the index of the last html node in the list of siblings
+      const lastHtmlIndex = locateIndexOfLastHtmlNode(siblings, index);
+
+      // get the node's value and store it in html variable
+      let html = node.value;
+
+      // if there are more html nodes after this one, remove them from the siblings array
+      if (lastHtmlIndex > index) {
+        // splice the siblings array to remove the nodes that are between the
+        // current node and the last html node, leaving the siblings array with
+        // only the nodes that come before the first HTML node, and include the
+        // first HTML node
+        const removed = siblings.splice(index + 1, lastHtmlIndex - index);
+
+        // append to html as special markdown element marker which is then handled in the
+        // mdHandler for the `<markdown>` elements.
+        removed.forEach((n) => {
+          if (n.type === 'html' || n.type === 'text') {
+            html += n.value;
+          } else {
+            // eventually toMdast will be called, and when we encounter a markdown element
+            // we need to replace it with the actual markdown content, so store the index
+            // such that we can look it up in the mdInserts array later.
+            html += `<markdown idx="${mdInserts.length}"></markdown>`;
+            mdInserts.push(n);
+          }
+        });
+      }
+
+      if (isPhrasingParent(parent)) {
+        html = `<p>${html}</p>`;
+      }
+
+      // try parse html
+      const hast = unified()
+        .use(parse, { fragment: true })
+        .parse(html);
+
+      // convert to mdast with extra handlers
+      const mdast = toMdast(hast, {
+        document: false,
+        handlers: {
+          ...defaultHandlers,
+          a: linkHandler,
+          u: formatHandler('underline'),
+          sub: formatHandler('subscript'),
+          sup: formatHandler('superscript'),
+          table: tableHandler,
+          markdown: mdHandler(mdInserts),
+          th: tableCellHandler,
+          td: tableCellHandler,
+        },
+      });
+      // clear inserts
+      mdInserts.length = 0;
+
+      // ensure that flow nodes are in phrasing context
+      if (!isPhrasingParent(parent)) {
+        let lastParagraph;
+        for (let idx = 0; idx < mdast.children.length; idx += 1) {
+          const child = mdast.children[idx];
+          if (child.type === 'underline' || child.type === 'subscript' || child.type === 'superscript') {
+            unwrapParagraphs(child);
+            if (!lastParagraph) {
+              lastParagraph = {
+                type: 'paragraph',
+                children: [child],
+              };
+              mdast.children.splice(idx, 1, lastParagraph);
+            } else {
+              lastParagraph.children.push(child);
+              mdast.children.splice(idx, 1);
+              idx -= 1;
+            }
+          } else {
+            lastParagraph = null;
+          }
+        }
+      } else {
+        unwrapParagraphs(mdast);
+      }
+
+      // inject children of parsed tree
+      siblings.splice(index, 1, ...mdast.children);
+
+      // continue after
+      return index + mdast.children.length;
+    }
+
+    return visit.CONTINUE;
+  });
+  return tree;
+}

package/src/mdast2jcr/templates/page-template.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2024 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.
+ */
+export default function pageTemplate() {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<jcr:root xmlns:jcr="http://www.jcp.org/jcr/1.0" xmlns:nt="http://www.jcp.org/jcr/nt/1.0" xmlns:cq="http://www.day.com/jcr/cq/1.0" xmlns:sling="http://sling.apache.org/jcr/sling/1.0" jcr:primaryType="cq:Page">
+    {{#page}}
+        <root jcr:primaryType="nt:unstructured" sling:resourceType="core/franklin/components/root/v1/root">
+            {{#each children }}
+                {{#section @index children }}
+                {{#each children }}
+                    {{> (whichPartial this.type) models=../../models definition=../../definition filters=../../filters}}
+                {{/each}}
+                {{/section}}
+            {{/each}}
+        </root>
+    {{/page}}
+</jcr:root>`;
+}

package/src/mdast2jcr/utils/mdast.js

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2024 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.
+ */
+
+/**
+ * findAll goes through the children of a node searching for nodes that match a
+ * test function.
+ *
+ * @param node the node to search through.
+ * @param test the test function
+ * @param flatten if true, the function will return the children of the matching nodes, without
+ * their parent.
+ * @return {*[]} an array of nodes that match the test function.
+ */
+function findAll(node, test, flatten = false) {
+  // given the root of the mdast tree, find all the nodes that are identified by the test function
+  const results = [];
+
+  if (test(node)) {
+    results.push(node);
+    return results;
+  }
+
+  if (node.children) {
+    node.children.forEach((child) => {
+      results.push(...findAll(child, test));
+    });
+  }
+
+  if (flatten) {
+    return results.map((c) => c.children).flat();
+  } else {
+    return results;
+  }
+}
+
+export {
+  findAll,
+};

package/src/mdast2jcr/utils.js

@@ -0,0 +1,233 @@
+/*
+ * Copyright 2021 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 Handlebars from 'handlebars';
+import { toString } from 'mdast-util-to-string';
+
+/* eslint-disable no-param-reassign */
+
+/**
+ * This method modifies the mdast tree in place. Given a flat list of nodes,
+ * gather the children of each section and wrap them in a section node.
+ * For example given a mdast tree of:
+ * [Heading, Text, Image, ThematicBreak, Text, ThematicBreak, Text] would
+ * result in [Section[Heading, Text, Image], Section[Text], Section[Text]].
+ */
+export function splitSection(mdast) {
+  // obtain the index of all thematicBreak nodes from the list of children
+  const thematicBreakIndexes = mdast.children
+    .filter((node) => node.type === 'thematicBreak')
+    // then get their index in the list of children
+    .map((node) => mdast.children.indexOf(node));
+
+  // find pairwise permutations of spaces between blocks
+  // include the very start and end of the document
+  const starts = [0, ...thematicBreakIndexes];
+  const ends = [...thematicBreakIndexes, mdast.children.length];
+
+  // content.mdast.children = _.zip(starts, ends)
+  const nodes = starts
+    .map((k, i) => [k, ends[i]])
+    // but filter out empty section
+    .filter(([start, end]) => start !== end);
+    // then return all nodes that are in between
+
+  mdast.children = nodes.map(([start, end]) => {
+    // skip 'thematicBreak' nodes
+    const index = mdast.children[start].type === 'thematicBreak' ? start + 1 : start;
+    return {
+      type: 'section',
+      children: mdast.children.slice(index, end),
+    };
+  });
+
+  // unwrap sole section directly on the root
+  // if (mdast.children.length === 1 && mdast.children[0].type === 'section') {
+  //   mdast.children = mdast.children[0].children;
+  // }
+
+  return mdast;
+}
+
+export function wrapParagraphs(mdast) {
+  const sections = mdast.children.filter((node) => node.type === 'section');
+
+  sections.forEach((section) => {
+    const { children } = section;
+    const newChildren = [];
+    let paragraphGroup = [];
+
+    // process.stdout.write('==================================================\n');
+    // process.stdout.write(inspect(section));
+    // process.stdout.write('\n');
+    // process.stdout.write('==================================================\n');
+
+    for (let i = 0; i < children.length; i += 1) {
+      const node = children[i];
+
+      // Group paragraph and heading (depth >= 3) into the same paragraphWrapper
+      // group strong and emphasis into the same paragraphWrapper if they are not a button
+      if (node.type === 'paragraph'
+        || node.type === 'list'
+        || node.type === 'code'
+        || (node.type === 'heading' && node.depth >= 3)
+        || (node.type === 'strong' && (node.children.length !== 1 || (node.children.length === 1 && node.children[0].type !== 'link')))
+        || (node.type === 'emphasis' && (node.children.length !== 1 || (node.children.length === 1 && node.children[0].type !== 'link')))
+      ) {
+        paragraphGroup.push(node);
+
+        if (i === children.length - 1) {
+          newChildren.push({
+            type: 'paragraphWrapper',
+            children: paragraphGroup,
+          });
+        }
+      } else {
+        if (paragraphGroup.length > 0) {
+          newChildren.push({
+            type: 'paragraphWrapper',
+            children: paragraphGroup,
+          });
+          paragraphGroup = [];
+        }
+        newChildren.push(node);
+      }
+    }
+    section.children = newChildren;
+
+    // process.stdout.write('==================================================\n');
+    // process.stdout.write(inspect(section));
+    // process.stdout.write('\n');
+    // process.stdout.write('==================================================\n');
+  });
+  return mdast;
+}
+
+export function unwrapImages(mdast) {
+  const sections = mdast.children.filter((node) => node.type === 'section');
+
+  sections.forEach((section) => {
+    const newChildren = [];
+
+    for (const node of section.children) {
+      if (node.type === 'paragraph') {
+        let currentText = [];
+        const images = [];
+
+        // Handle single child unwrapping for `link`, `strong`, and `em`
+        if (node.children.length === 1) {
+          const onlyChild = node.children[0];
+          if (['link', 'strong', 'emphasis'].includes(onlyChild.type)) {
+            // Move the single child outside the paragraph
+            newChildren.push(onlyChild);
+            // eslint-disable-next-line no-continue
+            continue; // Skip further processing of this paragraph node
+          }
+        }
+
+        // process.stdout.write('==================================================\n');
+        // process.stdout.write(inspect(node));
+        // process.stdout.write('\n');
+        // process.stdout.write('==================================================\n');
+
+        // Traverse paragraph children to separate images and text nodes
+        for (let i = 0; i < node.children.length; i += 1) {
+          const child = node.children[i];
+
+          if (child.type === 'image') {
+            // If we have accumulated text, push it as a paragraph before the image
+            if (currentText.length > 0) {
+              newChildren.push({
+                type: 'paragraph',
+                children: currentText,
+                position: node.position,
+              });
+              currentText = [];
+            }
+            // Push the image outside the paragraph
+            images.push(child);
+          } else {
+            // Collect non-image children as part of the paragraph
+            currentText.push(child);
+          }
+        }
+
+        // If there are remaining text nodes, add them as a paragraph
+        if (currentText.length > 0) {
+          newChildren.push({
+            type: 'paragraph',
+            children: currentText,
+            position: node.position,
+          });
+        }
+
+        // Move all images to their proper position in the parent tree
+        newChildren.push(...images);
+      } else {
+        // Non-paragraph nodes stay as they are
+        newChildren.push(node);
+      }
+    }
+
+    section.children = newChildren;
+  });
+  return mdast;
+}
+
+export function encodeHTMLEntities(str) {
+  return str ? str.replace(/&(?!amp;|lt;|gt;|quot;|apos;|#\d+;)/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/"/g, '&quot;') : '';
+}
+
+export function encodeHtml(str) {
+  return Handlebars.escapeExpression(str);
+}
+
+/**
+ * Strip the new line characters from the given value.  If the value is of Node, toString
+ * is then performed and then a replacement occurs.  If the value is a string, a simple replace
+ * is performed.
+ * @param value the string or Node to strip newlines from.
+ * @return {string} the string with newlines replaced with spaces.
+ */
+export function stripNewlines(value) {
+  if (!value) {
+    return '';
+  }
+
+  if (typeof value === 'string') {
+    return value.replace(/\n/g, ' ').trim();
+  }
+  return toString(value).replace(/\n/g, ' ').trim();
+}
+
+/**
+ * Sort properties by the following order: sling, jcr, other.
+ * @param {string} p1 - property 1
+ * @param {string} p2 - property 2
+ * @return {number} -1 if p1 is before p2, 1 if p2 is before p1, 0 if they are equal.
+ */
+export const sortJcrProperties = ([p1], [p2]) => {
+  if (p1.startsWith('sling:')) {
+    return -1;
+  }
+  if (p2.startsWith('sling:')) {
+    return 1;
+  }
+  if (p1.startsWith('jcr:')) {
+    return -1;
+  }
+  if (p2.startsWith('jcr:')) {
+    return 1;
+  }
+  return p1.localeCompare(p2);
+};