feat: add support for other assets like pdf, videos, docs, etc.

Author: ManasMaji

src/index.js

@@ -10,9 +10,9 @@
  * governing permissions and limitations under the License.
  */
 import { createJcrPackage } from './package/packaging.js';
-import { getImageUrlsFromMarkdown } from './package/image-mapping.js';
+import { getAssetUrlsFromMarkdown } from './package/asset-mapping.js';
 
 export {
   createJcrPackage,
-  getImageUrlsFromMarkdown,
+  getAssetUrlsFromMarkdown,
 };

src/package/image-mapping.js src/package/asset-mapping.js

@@ -18,6 +18,9 @@ const imageRegex = /!\[([^\]]*)]\(([^) "]+)(?: *"([^"]*)")?\)|!\[([^\]]*)]\[([^\
 // Regex for reference definitions
 const referenceRegex = /\[([^\]]+)]:\s*(\S+)/g;
 
+// Regex for non-image asset links (PDFs, videos, docs, etc.)
+const nonImageAssetRegex = /(?:\[(.*?)\]|\[.*?\])\(([^)]+\.(?:pdf|doc|docx|xls|xlsx|ppt|pptx|odt|ods|odp|rtf|txt|csv|mp4|mov|avi|wmv|mkv|flv|webm))\)|\[(.*?)\]:\s*(\S+\.(?:pdf|doc|docx|xls|xlsx|ppt|pptx|odt|ods|odp|rtf|txt|csv|mp4|mov|avi|wmv|mkv|flv|webm))/gi;
+
 /**
  * Function to find reference definitions in a markdown file.
  *
@@ -36,62 +39,71 @@ const findReferenceDefinitionsInMarkdown = (markdownContent) => {
 };
 
 /**
- * Function to scan for images in a markdown file.
+ * Function to scan for assets in a markdown file.
  *
  * @param markdownContent - The content of the markdown file
- * @returns {Array<string>} A Map of image urls as key
+ * @returns {Array<string>} A Map of asset urls as key
  */
-const findImagesInMarkdown = (markdownContent) => {
+const findAssetsInMarkdown = (markdownContent) => {
   const references = findReferenceDefinitionsInMarkdown(markdownContent);
 
-  const imageUrls = [];
+  const assetUrls = [];
 
   // Identify each image url in the markdown content
   let match;
+  let url;
   // eslint-disable-next-line no-cond-assign
   while ((match = imageRegex.exec(markdownContent)) !== null) {
-    let url;
     if (match[2]) { // Inline image
       // eslint-disable-next-line prefer-destructuring
       url = match[2];
     } else if (match[5]) { // Reference-style image
       url = references[match[5]] || null; // Resolve URL from reference map
     }
     if (url) {
-      imageUrls.push(url);
+      assetUrls.push(url);
+    }
+  }
+
+  // Find and add only non-image asset links
+  // eslint-disable-next-line no-cond-assign
+  while ((match = nonImageAssetRegex.exec(markdownContent)) !== null) {
+    url = match[2] || match[3];
+    if (url) {
+      assetUrls.push(url);
     }
   }
 
-  return imageUrls;
+  return assetUrls;
 };
 
 /**
- * Get the list image urls present in the markdown.
+ * Get the list asset urls present in the markdown.
  * @param {string} markdownContent - The content of the markdown file
- * @returns {Array<string>} An array of image urls.
+ * @returns {Array<string>} An array of asset urls.
  */
-const getImageUrlsFromMarkdown = (markdownContent) => {
+const getAssetUrlsFromMarkdown = (markdownContent) => {
   try {
-    return findImagesInMarkdown(markdownContent);
+    return findAssetsInMarkdown(markdownContent);
   } catch (error) {
     // eslint-disable-next-line no-console
-    console.warn('Error getting image urls from markdown:', error);
+    console.warn('Error getting asset urls from markdown:', error);
     return [];
   }
 };
 
 /**
- * Function to sanitize the image mappings.
+ * Function to sanitize the asset url mappings.
  * Delete all entries with empty values (meaning that they have not been used in any jcr page).
- * @param {Map} imageMap - The image mapping
- * @returns {Map} The sanitized image mapping
+ * @param {Map} assetMap - The asset url mapping
+ * @returns {Map} The sanitized asset url mapping
  */
-const sanitizeImageMappings = (imageMap) => (
-  new Map([...imageMap].filter((entry) => entry[1] != null && entry[1] !== ''))
+const sanitizeAssetMappings = (assetMap) => (
+  new Map([...assetMap].filter((entry) => entry[1] != null && entry[1] !== ''))
 );
 
 export {
   // eslint-disable-next-line import/prefer-default-export
-  getImageUrlsFromMarkdown,
-  sanitizeImageMappings,
+  getAssetUrlsFromMarkdown,
+  sanitizeAssetMappings,
 };

src/package/packaging.js

@@ -22,10 +22,10 @@ import {
   traverseAndUpdateAssetReferences,
 } from './packaging.utils.js';
 import { saveFile } from '../shared/filesystem.js';
-import { sanitizeImageMappings } from './image-mapping.js';
+import { sanitizeAssetMappings } from './asset-mapping.js';
 
 let jcrPages = [];
-const IMAGE_MAPPING_FILE = 'image-mappings.json';
+const ASSET_MAPPING_FILE = 'asset-mappings.json';
 
 const init = () => {
   jcrPages = [];
@@ -41,10 +41,10 @@ const addPage = async (page, dir, prefix, zip) => {
  * @param xml - The xml content of the page
  * @param pageUrl - The url of the site page
  * @param assetFolderName - The name of the asset folder(s) in AEM
- * @param imageMappings - A map to store the image urls and their corresponding jcr paths
+ * @param assetMappings - A map to store the asset urls and their corresponding jcr paths
  * @returns {Promise<*|string>} - The updated xml content
  */
-export const updateAssetReferences = async (xml, pageUrl, assetFolderName, imageMappings) => {
+export const updateAssetReferences = async (xml, pageUrl, assetFolderName, assetMappings) => {
   let doc;
   try {
     doc = getParsedXml(xml);
@@ -55,14 +55,14 @@ export const updateAssetReferences = async (xml, pageUrl, assetFolderName, image
   }
 
   // Start traversal from the document root and update the asset references
-  traverseAndUpdateAssetReferences(doc.documentElement, pageUrl, assetFolderName, imageMappings);
+  traverseAndUpdateAssetReferences(doc.documentElement, pageUrl, assetFolderName, assetMappings);
 
   const serializer = new XMLSerializer();
   return serializer.serializeToString(doc);
 };
 
 // eslint-disable-next-line max-len
-export const getJcrPages = async (pages, siteFolderName, assetFolderName, imageMappings) => Promise.all(pages.map(async (page) => ({
+export const getJcrPages = async (pages, siteFolderName, assetFolderName, assetMappings) => Promise.all(pages.map(async (page) => ({
   path: page.path,
   sourceXml: page.data,
   pageProperties: getPageProperties(page.data),
@@ -71,7 +71,7 @@ export const getJcrPages = async (pages, siteFolderName, assetFolderName, imageM
     page.data,
     page.url,
     assetFolderName,
-    imageMappings,
+    assetMappings,
   ),
   jcrPath: getJcrPagePath(page.path, siteFolderName),
   contentXmlPath: `jcr_root${getJcrPagePath(page.path, siteFolderName)}/.content.xml`,
@@ -121,34 +121,34 @@ const getEmptyAncestorPages = (pages) => {
 };
 
 /**
- * Sanitizes (deleting entries without jcr path mapping) and saves the image mappings to a file.
- * @param {Array<string>} imageUrls - An array of image urls that were found in the markdown.
+ * Sanitizes (deleting entries without jcr path mapping) and saves the asset mappings to a file.
+ * @param {*} assetMappings - The asset mappings
  * @param {*} outputDirectory - The directory handle
  */
-const sanitizeAndSaveImageMappings = async (imageMappings, outputDirectory) => {
-  // Sanitize the image mappings
-  const sanitizedMappings = sanitizeImageMappings(imageMappings);
+const sanitizeAndSaveAssetMappings = async (assetMappings, outputDirectory) => {
+  // Sanitize the asset mappings
+  const sanitizedMappings = sanitizeAssetMappings(assetMappings);
 
   // Convert Map to a plain object
   const obj = Object.fromEntries(sanitizedMappings);
 
-  // Save the updated image mapping content into a file
-  await saveFile(outputDirectory, IMAGE_MAPPING_FILE, JSON.stringify(obj, null, 2));
+  // Save the updated asset mapping content into a file
+  await saveFile(outputDirectory, ASSET_MAPPING_FILE, JSON.stringify(obj, null, 2));
 };
 
 /**
  * Creates a JCR content package from a directory containing pages.
  * @param {*} outputDirectory - The directory handle
  * @param {Array} pages - An array of pages
- * @param {Array<string>} imageUrls - An array of image urls that were found in the markdown.
+ * @param {Array<string>} assetUrls - An array of asset urls that were found in the markdown.
  * @param {string} siteFolderName - The name of the site folder(s) in AEM
  * @param {string} assetFolderName - The name of the asset folder(s) in AEM
  * @returns {Promise} The file handle for the generated package.
  */
 export const createJcrPackage = async (
   outputDirectory,
   pages,
-  imageUrls,
+  assetUrls,
   siteFolderName,
   assetFolderName,
 ) => {
@@ -162,10 +162,10 @@ export const createJcrPackage = async (
   const prefix = 'jcr';
 
   // create a map using the provided asset urls as keys (values will be populated later)
-  const imageMappings = new Map(imageUrls.map((url) => [url, '']));
+  const assetMappings = new Map(assetUrls.map((url) => [url, '']));
 
   // add the pages
-  jcrPages = await getJcrPages(pages, siteFolderName, assetFolderName, imageMappings);
+  jcrPages = await getJcrPages(pages, siteFolderName, assetFolderName, assetMappings);
   for (let i = 0; i < jcrPages.length; i += 1) {
     const page = jcrPages[i];
     // eslint-disable-next-line no-await-in-loop
@@ -192,5 +192,5 @@ export const createJcrPackage = async (
   await zip.generateAsync({ type: outputType })
     .then(async (blob) => saveFile(outputDirectory, `${packageName}.zip`, blob));
 
-  await sanitizeAndSaveImageMappings(imageMappings, outputDirectory);
+  await sanitizeAndSaveAssetMappings(assetMappings, outputDirectory);
 };

test/package/image-mapping.test.js

@@ -11,7 +11,7 @@
  */
 /* eslint-env mocha */
 import { expect } from 'chai';
-import { getImageUrlsFromMarkdown, sanitizeImageMappings } from '../../src/package/image-mapping.js';
+import { getAssetUrlsFromMarkdown, sanitizeAssetMappings } from '../../src/package/asset-mapping.js';
 
 describe('getImageUrlsFromMarkdown', () => {
   it('should return an array of image urls (reference urls)', () => {
@@ -25,7 +25,7 @@ describe('getImageUrlsFromMarkdown', () => {
 [image0]: https://aem.live/car.jpeg
 [image1]: https://aem.live/car2.jpeg`;
 
-    const imageUrls = getImageUrlsFromMarkdown(markdownContent);
+    const imageUrls = getAssetUrlsFromMarkdown(markdownContent);
     expect(imageUrls).to.have.lengthOf(2);
     expect(imageUrls[0]).to.equal('https://aem.live/car.jpeg');
     expect(imageUrls[1]).to.equal('https://aem.live/car2.jpeg');
@@ -39,16 +39,25 @@ describe('getImageUrlsFromMarkdown', () => {
 | ![Car 2](https://aem.live/car2.jpeg)     |
 +------------------------------------------+`;
 
-    const imageUrls = getImageUrlsFromMarkdown(markdownContent);
+    const imageUrls = getAssetUrlsFromMarkdown(markdownContent);
     expect(imageUrls).to.have.lengthOf(2);
     expect(imageUrls[0]).to.equal('https://aem.live/car.jpeg');
     expect(imageUrls[1]).to.equal('https://aem.live/car2.jpeg');
   });
 
+  it('should return an non-image asset (pdf) url', () => {
+    const markdownContent = `Click [here](/content/dam/doe/foo/bar.pdf) to download the handy guide.
+    Also check [here](https://example.live/siteFoo.html).`;
+
+    const imageUrls = getAssetUrlsFromMarkdown(markdownContent);
+    expect(imageUrls).to.have.lengthOf(1);
+    expect(imageUrls[0]).to.equal('/content/dam/doe/foo/bar.pdf');
+  });
+
   it('should return an array with no image urls', () => {
     const markdownContent = 'This is a markdown file with no images.';
 
-    const imageUrls = getImageUrlsFromMarkdown(markdownContent);
+    const imageUrls = getAssetUrlsFromMarkdown(markdownContent);
     expect(imageUrls).to.have.lengthOf(0);
   });
 
@@ -62,7 +71,7 @@ describe('getImageUrlsFromMarkdown', () => {
 
 [image0]: /test/car2.jpeg`;
 
-    const imageUrls = getImageUrlsFromMarkdown(markdownContent);
+    const imageUrls = getAssetUrlsFromMarkdown(markdownContent);
     expect(imageUrls).to.have.lengthOf(2);
     expect(imageUrls[0]).to.equal('/car.jpeg');
     expect(imageUrls[1]).to.equal('/test/car2.jpeg');
@@ -77,7 +86,7 @@ describe('getImageUrlsFromMarkdown', () => {
       ['key5', 'value5'],
     ]);
 
-    const result = sanitizeImageMappings(imageMap);
+    const result = sanitizeAssetMappings(imageMap);
 
     expect(result.size).to.equal(2);
     expect(result.has('key1')).to.equal(true);
@@ -94,7 +103,7 @@ describe('getImageUrlsFromMarkdown', () => {
       ['key3', undefined],
     ]);
 
-    const result = sanitizeImageMappings(imageMap);
+    const result = sanitizeAssetMappings(imageMap);
 
     expect(result.size).to.equal(0);
   });