@adobe/helix-md2jcr 1.0.0

package/src/mdast2jcr/hb/partials/supports/image.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.
+ */
+import { find } from 'unist-util-find';
+
+const image = {
+  supports: (node) => find(node, { type: 'image' }) !== undefined,
+
+  getProperties: (node) => {
+    const imageNode = find(node, { type: 'image' });
+    return {
+      url: imageNode?.url || '',
+      alt: imageNode?.alt || '',
+      label: imageNode?.label || '',
+    };
+  },
+};
+
+export default image;

package/src/mdast2jcr/hb/partials/supports/link.js

@@ -0,0 +1,46 @@
+/*
+ * 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.
+ */
+import { find } from 'unist-util-find';
+
+/** @typedef {import('mdast').Node} Node */
+
+const link = {
+  supports: (node) => find(node, { type: 'link' }) !== undefined,
+
+  /**
+   * Returns the type of the link based on the node's parent.  Links can be wrapped
+   * in either strong or emphasis tags to denote primary and secondary links respectively.
+   * @param parentNode {Node} The parent node of the link
+   * @return {string} The type of the link (primary, secondary, or empty string)
+   */
+  getType: (parentNode) => {
+    if (find(parentNode, { type: 'emphasis' })) {
+      return 'secondary';
+    }
+    if (find(parentNode, { type: 'strong' })) {
+      return 'primary';
+    }
+    return '';
+  },
+
+  getProperties: (child) => {
+    const node = find(child, { type: 'link' });
+    const text = find(node, { type: 'text' });
+    return {
+      href: node.url,
+      text: text?.value || '',
+    };
+  },
+
+};
+
+export default link;

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

@@ -0,0 +1,16 @@
+/*
+ * 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.
+ */
+function tablePartial() {
+  return '<section></section>\n';
+}
+
+export default tablePartial;

package/src/mdast2jcr/index.d.ts

@@ -0,0 +1,122 @@
+/*
+ * 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.
+ */
+
+/**
+ * The Field object that represents a field in the model.
+ *
+ * https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/implementing/developing/universal-editor/field-types#component-types
+ */
+export interface FieldDef {
+  component: 'group' | 'aem-tag' | 'aem-content' | 'boolean' | 'checkbox-group' | 'container' |
+      'aem-content-fragment' | 'date-time' | 'aem-experience-fragment' | 'multiselect' |
+      'number' | 'radio-group' | 'reference' | 'richtext' | 'select' | 'tab' | 'text';
+  valueType: string;
+  name: string;
+  label: string;
+  value?: string;
+  multi?: boolean;
+  fields?: FieldDef[]; // for nested fields that have a component value type "group"
+}
+
+/**
+ * The Model object that represents a block's model mapping that should be used to generate
+ * the jcr xml.
+ */
+export interface ModelDef {
+  /**
+   * The id of the model.
+   */
+  id: string;
+
+  /**
+   * A list of fields that are to be used to map the mdast to the jcr xml.
+   */
+  fields: FieldDef[];
+}
+
+export type ResourceType = 'core/franklin/components/text/v1/text'
+    | 'core/franklin/components/text/v1/block'
+    | 'core/franklin/components/block/v1/block/item'
+    | 'core/franklin/components/title/v1/title'
+    | 'core/franklin/components/image/v1/image'
+    | 'core/franklin/components/button/v1/button'
+    | 'core/franklin/components/section/v1/section'
+    | 'core/franklin/components/columns/v1/columns'
+    | 'core/franklin/components/page/v1/page';
+
+export interface ComponentDef {
+  title: string;
+  id: string;
+  plugins: {
+    xwalk: {
+      page: {
+        resourceType: ResourceType;
+        template: {
+          [key: string]: string;
+        }
+      };
+    };
+  };
+}
+
+export interface GroupDef {
+  title: string;
+  id: string;
+  components: Array<ComponentDef>;
+}
+
+export interface DefinitionDef {
+  groups: Array<GroupDef>;
+}
+
+export interface Filter {
+  id: string,
+  components: Array<string>;
+}
+
+/**
+ * Options object for the mdast to jcr conversion.
+ */
+export interface Mdast2JCROptions {
+  /**
+   * An array of models that should be used to generate the jcr xml.
+   */
+  models: Array<ModelDef>;
+
+  /**
+   * A definition object containing groups and components.
+   */
+  definition: DefinitionDef;
+
+  /**
+   * Defines the filters.
+   */
+  filters: Array<Filter>;
+}
+
+/**
+ * The keys are the base names of the properties, and the values are objects with the full
+ * property names as keys and the field objects as values.
+ */
+export interface CollapsedFields {
+  [key: string]: {
+    [key: string]: FieldDef;
+  };
+}
+
+/**
+ * Converts the mdast to a jcr xml markup.
+ * @param {Node} mdast The mdast
+ * @param {Mdast2JCROptions} [opts] options
+ * @returns {Promise<string>} the xml markup
+ */
+export default function mdast2jcr(mdast: object, opts?: Mdast2JCROptions): Promise<string>;

package/src/mdast2jcr/index.js

@@ -0,0 +1,94 @@
+/*
+ * 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.
+ */
+
+/* eslint-disable no-param-reassign */
+import Handlebars from 'handlebars';
+import xmlFormatter from 'xml-formatter';
+import { splitSection, unwrapImages as unwrapElements, wrapParagraphs } from './utils.js';
+import sanitizeHtml from './mdast-sanitize-html.js';
+import headingPartial from './hb/partials/heading.js';
+import stringPartial from './hb/partials/strong.js';
+import emphasisPartial from './hb/partials/emphasis.js';
+import linkPartial from './hb/partials/link.js';
+import paragraphWrapperPartial from './hb/partials/paragraph.js';
+import nameHelper, { nameReset } from './hb/helpers/name-helper.js';
+import sectionHelper from './hb/helpers/section-helper.js';
+import imagePartial from './hb/partials/image.js';
+import encodeHelper from './hb/helpers/encode-helper.js';
+import whichPartialHelper from './hb/helpers/which-partial-helper.js';
+import gridTablePartial from './hb/partials/grid-table.js';
+import blockQuotePartial from './hb/partials/blockquote.js';
+import tablePartial from './hb/partials/table.js';
+import pageHelper from './hb/helpers/page-helper.js';
+import pageTemplate from './templates/page-template.js';
+
+/**
+ * Converts a markdown AST to JCR XML.  This function is the main entry point
+ * for the mdast2jcr module. The function takes a markdown AST and an options
+ * object as input and returns a promise that resolves to a string containing
+ * the JCR XML representation of the markdown AST.
+ * @param mdast The markdown AST to convert to JCR XML.
+ * @param {Mdast2JCROptions} options An options object that can be used to customize the conversion.
+ * @returns {Promise<string>}
+ */
+export default async function mdast2jcr(mdast, options = {}) {
+  mdast = sanitizeHtml(mdast);
+  mdast = splitSection(mdast);
+  mdast = unwrapElements(mdast);
+  mdast = wrapParagraphs(mdast);
+
+  Handlebars.registerPartial('heading', headingPartial);
+  Handlebars.registerPartial('image', imagePartial);
+  Handlebars.registerPartial('link', linkPartial);
+  Handlebars.registerPartial('strong', stringPartial);
+  Handlebars.registerPartial('emphasis', emphasisPartial);
+  Handlebars.registerPartial('paragraphWrapper', paragraphWrapperPartial);
+  Handlebars.registerPartial('gridTable', gridTablePartial);
+  Handlebars.registerPartial('blockquote', blockQuotePartial); // TODO
+  Handlebars.registerPartial('table', tablePartial); // TODO
+
+  Handlebars.registerHelper('whichPartial', whichPartialHelper);
+  Handlebars.registerHelper('encode', encodeHelper);
+  Handlebars.registerHelper('nameHelper', nameHelper);
+  Handlebars.registerHelper('section', sectionHelper);
+  Handlebars.registerHelper('page', pageHelper);
+
+  // reset the name helper counter
+  nameReset();
+
+  // register page template
+  const pageTemplateXML = pageTemplate();
+
+  const template = Handlebars.compile(pageTemplateXML);
+
+  const ctx = {
+    models: options.models,
+    definition: options.definition,
+    filters: options.filters,
+    children: mdast.children,
+  };
+
+  let xml = template(ctx);
+
+  xml = xmlFormatter(xml, {
+    indentation: '  ', // 2 spaces
+    filter: (node) => node.type !== 'Comment', // Remove comments
+    collapseContent: true,
+    lineSeparator: '\n',
+  });
+
+  if (process.env.NODE_ENV === 'debug') {
+    console.log(xml);
+  }
+
+  return xml;
+}

package/src/mdast2jcr/mdast-download-images.js

@@ -0,0 +1,165 @@
+/*
+ * 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.
+ */
+/* eslint-disable no-param-reassign */
+import crypto from 'crypto';
+import { context as fetchAPI, h1 } from '@adobe/fetch';
+import processQueue from '@adobe/helix-shared-process-queue';
+import { visit } from 'unist-util-visit';
+import getDimensions from 'image-size';
+import mime from 'mime';
+
+function createFetchContext() {
+  return process.env.HELIX_FETCH_FORCE_HTTP1
+    ? h1()
+    : fetchAPI();
+}
+
+function hsize(bytes, decimals = 2) {
+  if (bytes === 0) {
+    return '0   ';
+  }
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ['  ', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
+}
+
+/**
+ * @param ctx
+ * @param tree
+ * @returns {Promise<void>}
+ */
+export default async function downloadImages(ctx, tree) {
+  const { log, resourceLoader, image2png } = ctx;
+  const context = createFetchContext();
+  const { fetch } = context;
+
+  // gather all image nodes
+  const images = [];
+  visit(tree, (node) => {
+    if (node.type === 'image' && node.url) {
+      images.push(node);
+    }
+    return visit.CONTINUE;
+  });
+  let count = 0;
+
+  // download images
+  await processQueue(images, async (node) => {
+    try {
+      const ref = crypto.createHash('sha1')
+        .update(node.url)
+        .digest('hex');
+      node.data = ctx.images[ref];
+      if (node.data) {
+        return;
+      }
+      const idx = String(count).padStart(2, ' ');
+      count += 1;
+      let buffer;
+      let type = 'application/octet-stream';
+      let maybeConvert;
+      let dimensions = {
+        width: 100,
+        height: 100,
+      };
+      if (node.url.startsWith('data:')) {
+        const [prefix, data] = node.url.substring(5).split(',');
+        const [typ, enc] = prefix.split(';');
+        if (enc !== 'base64') {
+          log.warn(`[${idx}] Error decoding data url. unknown encoding: ${enc}`);
+          return;
+        }
+        buffer = Buffer.from(data, 'base64');
+        type = typ;
+      } else {
+        log.info(`[${idx}] GET ${node.url}`);
+
+        let doFetch = fetch;
+        if (node.url.startsWith('res:')) {
+          if (!resourceLoader) {
+            log.warn(`[${idx}] Error loading image ${node.url}. resource loader missing.`);
+            return;
+          }
+          doFetch = resourceLoader.fetch.bind(resourceLoader);
+        }
+
+        const ret = await doFetch(node.url);
+        if (!ret.ok) {
+          const text = await ret.text();
+          log.error(`[${idx}] ${ret.status} ${text}`);
+          return;
+        }
+        buffer = await ret.buffer();
+        type = ret.headers.get('content-type');
+        log.info(`[${idx}] ${ret.status} ${hsize(buffer.length).padStart(10)} ${type}`);
+      }
+
+      try {
+        dimensions = getDimensions(buffer);
+        type = mime.getType(dimensions.type);
+      } catch (e) {
+        maybeConvert = true;
+        log.warn(`[${idx}] Error detecting dimensions: ${e} ${type}`);
+      }
+
+      if (!maybeConvert) {
+        // only convert unknown and images
+        maybeConvert = type === 'application/octet-stream'
+          || (type.startsWith('image/') && type !== 'image/png' && type !== 'image/jpg' && type !== 'image/jpeg' && type !== 'image/gif');
+      }
+
+      let originalBuffer;
+      let originalType;
+      if (maybeConvert && image2png) {
+        try {
+          const result = await image2png({
+            src: node.url,
+            data: buffer,
+            type,
+          });
+          if (result) {
+            originalBuffer = buffer;
+            originalType = type;
+            buffer = result.data;
+            type = result.type;
+            dimensions = {
+              width: result.width,
+              height: result.height,
+            };
+          }
+        } catch (e) {
+          log.warn(`[${idx}] Error to convert to png`, e);
+        }
+      }
+
+      const ext = mime.getExtension(type);
+
+      node.data = {
+        ext,
+        key: `${ref}.${ext}`,
+        buffer,
+        originalBuffer,
+        type,
+        originalType,
+        dimensions,
+      };
+      ctx.images[ref] = node.data;
+    } catch (error) {
+      log.error(`Cannot download image ${node.url}: ${error.message}`);
+    }
+  }, 8);
+
+  // reset fetch context
+  context.reset();
+}