Feat: Initial Hyperlink Support (Backfitted from MP70)

Author: MP70

__tests__/modify-hyperlink.test.ts

@@ -1,4 +1,8 @@
 import Automizer from '../src/index';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as JSZip from 'jszip';
+import { DOMParser } from '@xmldom/xmldom';
 
 test('Add and modify hyperlinks', async () => {
   const automizer = new Automizer({
@@ -11,12 +15,71 @@ test('Add and modify hyperlinks', async () => {
     .load(`EmptySlide.pptx`, 'empty')
     .load(`SlideWithLink.pptx`, 'link');
 
+  // Track if the hyperlink was added
+  const outputFile = `modify-hyperlink.test.pptx`;
+  const outputPath = path.join(`${__dirname}/pptx-output`, outputFile);
+
   const result = await pres
-    .addSlide('link', 1, (slide) => {})
+    // Add the slide with the existing hyperlink
     .addSlide('empty', 1, (slide) => {
-      slide.addElement('link', 1, 'Link');
+      // Add the element with the hyperlink from the source slide
+      slide.addElement('link', 1, 'ExternalLink');
     })
-    .write(`modify-hyperlink.test.pptx`);
+    .write(outputFile);
 
-  expect(result.slides).toBe(3);
+  // Verify the number of slides
+  expect(result.slides).toBe(2);
+  
+  // Now verify that the hyperlink was actually copied by checking the PPTX file
+  // Read the generated PPTX file
+  const fileData = fs.readFileSync(outputPath);
+  const zip = await JSZip.loadAsync(fileData);
+  
+  // The second slide should be slide2.xml (index starts at 1 in PPTX)
+  // Check its relationships file for hyperlink entries
+  const slideRelsPath = 'ppt/slides/_rels/slide2.xml.rels';
+  const slideRelsFile = zip.file(slideRelsPath);
+  
+  // Make sure the file exists
+  expect(slideRelsFile).not.toBeNull();
+  
+  // Get the file content
+  const slideRelsXml = await slideRelsFile!.async('text');
+  
+  // Parse the XML
+  const parser = new DOMParser();
+  const xmlDoc = parser.parseFromString(slideRelsXml, 'application/xml');
+  
+  // Look for hyperlink relationships
+  const relationships = xmlDoc.getElementsByTagName('Relationship');
+  let hasHyperlink = false;
+  let hyperlinkId = '';
+  
+  for (let i = 0; i < relationships.length; i++) {
+    const relationship = relationships[i];
+    const type = relationship.getAttribute('Type');
+    if (type === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink') {
+      hasHyperlink = true;
+      const id = relationship.getAttribute('Id');
+      hyperlinkId = id || '';
+      break;
+    }
+  }
+  
+  // Verify that a hyperlink relationship exists
+  expect(hasHyperlink).toBe(true);
+  expect(hyperlinkId).not.toBe('');
+  
+  // Now check if the slide XML contains the hyperlink reference
+  const slidePath = 'ppt/slides/slide2.xml';
+  const slideFile = zip.file(slidePath);
+  
+  // Make sure the file exists
+  expect(slideFile).not.toBeNull();
+  
+  // Get the file content
+  const slideXml = await slideFile!.async('text');
+  
+  // Verify that the hyperlink ID is referenced in the slide content
+  expect(slideXml.includes(`r:id="${hyperlinkId}"`)).toBe(true);
 });

src/classes/has-shapes.ts

@@ -36,6 +36,7 @@ import { ElementType } from '../enums/element-type';
 import { GenericShape } from '../shapes/generic';
 import { XmlSlideHelper } from '../helper/xml-slide-helper';
 import { OLEObject } from '../shapes/ole';
+import { Hyperlink } from '../shapes/hyperlink';
 
 export default class HasShapes {
   /**
@@ -420,6 +421,21 @@ export default class HasShapes {
             info.mode
           ](this.targetTemplate, this.targetNumber, this.targetType);
           break;
+        case ElementType.Hyperlink:
+          // For hyperlinks, we need to handle them differently
+          if (info.target) {
+            await new Hyperlink(
+              info, 
+              this.targetType, 
+              this.sourceArchive,
+              info.target.isExternal ? 'external' : 'internal',
+              info.target.file
+            )[info.mode](
+              this.targetTemplate, 
+              this.targetNumber
+            );
+          }
+          break;
         default:
           break;
       }
@@ -787,7 +803,7 @@ export default class HasShapes {
           sourceArchive: this.sourceArchive,
           sourceSlideNumber: this.sourceNumber,
         },
-        this.targetType,
+        this.targetType
       ).modifyOnAddedSlide(this.targetTemplate, this.targetNumber);
     }
 
@@ -800,14 +816,11 @@ export default class HasShapes {
           sourceArchive: this.sourceArchive,
           sourceSlideNumber: this.sourceNumber,
         },
-        this.targetType,
+        this.targetType
       ).modifyOnAddedSlide(this.targetTemplate, this.targetNumber);
     }
 
-    const oleObjects = await OLEObject.getAllOnSlide(
-      this.sourceArchive,
-      this.relsPath,
-    );
+    const oleObjects = await OLEObject.getAllOnSlide(this.sourceArchive, this.relsPath);
     for (const oleObject of oleObjects) {
       await new OLEObject(
         {
@@ -817,9 +830,33 @@ export default class HasShapes {
           sourceSlideNumber: this.sourceNumber,
         },
         this.targetType,
-        this.sourceArchive,
+        this.sourceArchive
       ).modifyOnAddedSlide(this.targetTemplate, this.targetNumber, oleObjects);
     }
+
+    // Copy hyperlinks
+    const hyperlinks = await Hyperlink.getAllOnSlide(this.sourceArchive, this.relsPath);
+    for (const hyperlink of hyperlinks) {
+      // Create a new hyperlink with the correct target information
+      const hyperlinkInstance = new Hyperlink(
+        {
+          mode: 'append',
+          target: hyperlink,
+          sourceArchive: this.sourceArchive,
+          sourceSlideNumber: this.sourceNumber,
+        },
+        this.targetType,
+        this.sourceArchive,
+        hyperlink.isExternal ? 'external' : 'internal',
+        hyperlink.file
+      );
+      
+      // Ensure the target property is properly set
+      hyperlinkInstance.target = hyperlink;
+      
+      // Process the hyperlink
+      await hyperlinkInstance.modifyOnAddedSlide(this.targetTemplate, this.targetNumber, hyperlinks);
+    }
   }
 
   /**
@@ -894,11 +931,53 @@ export default class HasShapes {
       } as AnalyzedElementType;
     }
 
+    // Check for hyperlinks in text runs
+    const hasHyperlink = this.findHyperlinkInElement(sourceElement);
+    if (hasHyperlink) {
+      try {
+        const target = await XmlHelper.getTargetByRelId(
+          sourceArchive,
+          relsPath,
+          sourceElement,
+          'hyperlink',
+        );
+
+        return {
+          type: ElementType.Hyperlink,
+          target: target,
+          element: sourceElement,
+        } as AnalyzedElementType;
+      } catch (error) {
+        console.warn('Error finding hyperlink target:', error);
+      }
+    }
+
     return {
       type: ElementType.Shape,
     } as AnalyzedElementType;
   }
 
+  // Helper method to find hyperlinks in an element
+  private findHyperlinkInElement(element: XmlElement): boolean {
+    // Check for direct hyperlinks
+    const directHyperlinks = element.getElementsByTagName('a:hlinkClick');
+    if (directHyperlinks.length > 0) {
+      return true;
+    }
+
+    // Check for hyperlinks in text runs
+    const textRuns = element.getElementsByTagName('a:r');
+    for (let i = 0; i < textRuns.length; i++) {
+      const run = textRuns[i];
+      const rPr = run.getElementsByTagName('a:rPr')[0];
+      if (rPr && rPr.getElementsByTagName('a:hlinkClick').length > 0) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
   /**
    * Applys modifications
    * @internal

src/classes/shape.ts

@@ -108,13 +108,47 @@ export class Shape {
       .getElementsByTagName('p:spTree')[0]
       .appendChild(this.targetElement);
 
+    // Process hyperlinks in the element if this is a hyperlink element
+    if (this.relRootTag === 'a:hlinkClick') {
+      await this.processHyperlinks(targetSlideXml);
+    }
+
     XmlHelper.writeXmlToArchive(
       this.targetArchive,
       this.targetSlideFile,
       targetSlideXml,
     );
   }
 
+  // Process hyperlinks in the element
+  async processHyperlinks(targetSlideXml: XmlDocument): Promise<void> {
+    // Find all text runs in the element
+    const runs = this.targetElement.getElementsByTagName('a:r');
+    
+    for (let i = 0; i < runs.length; i++) {
+      const run = runs[i];
+      const rPr = run.getElementsByTagName('a:rPr')[0];
+      
+      if (rPr) {
+        // Find hyperlink elements
+        const hlinkClicks = rPr.getElementsByTagName('a:hlinkClick');
+        
+        for (let j = 0; j < hlinkClicks.length; j++) {
+          const hlinkClick = hlinkClicks[j];
+          const sourceRid = hlinkClick.getAttribute('r:id');
+          
+          if (sourceRid) {
+            // Update the r:id attribute to use the created relationship ID
+            hlinkClick.setAttribute('r:id', this.createdRid);
+            
+            // Ensure the xmlns:r attribute is set
+            hlinkClick.setAttribute('xmlns:r', 'http://schemas.openxmlformats.org/officeDocument/2006/relationships');
+          }
+        }
+      }
+    }
+  }
+
   async replaceIntoSlideTree(): Promise<void> {
     await this.modifySlideTree(true);
   }
@@ -155,6 +189,11 @@ export class Shape {
       sourceElementOnTargetSlide,
     );
 
+    // Process hyperlinks in the element if this is a hyperlink element
+    if (this.relRootTag === 'a:hlinkClick') {
+      await this.processHyperlinks(targetSlideXml);
+    }
+
     XmlHelper.writeXmlToArchive(archive, slideFile, targetSlideXml);
   }
 

src/constants/constants.ts

@@ -25,6 +25,17 @@ export const TargetByRelIdMap = {
     relAttribute: 'r:embed',
     prefix: '../media/image',
   } as TargetByRelIdMapParam,
+  hyperlink: {
+    relRootTag: 'a:hlinkClick',
+    relAttribute: 'r:id',
+    prefix: '',
+    findAll: true,
+  } as TargetByRelIdMapParam,
+  oleObject: {
+    relRootTag: 'p:oleObj',
+    relAttribute: 'r:id',
+    prefix: '../embeddings/oleObject',
+  } as TargetByRelIdMapParam,
 };
 
 export const imagesTrack: () => TrackedRelation[] = () => [
@@ -42,6 +53,15 @@ export const imagesTrack: () => TrackedRelation[] = () => [
   },
 ];
 
+export const hyperlinksTrack: () => TrackedRelation[] = () => [
+  {
+    type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink',
+    tag: 'a:hlinkClick',
+    role: 'hyperlink',
+    attribute: 'r:id',
+  },
+];
+
 export const contentTrack = (): TrackedRelationTag[] => {
   return [
     {
@@ -76,6 +96,7 @@ export const contentTrack = (): TrackedRelationTag[] => {
           tag: null,
         },
         ...imagesTrack(),
+        ...hyperlinksTrack(),
       ],
     },
     {
@@ -101,6 +122,7 @@ export const contentTrack = (): TrackedRelationTag[] => {
           role: 'slideLayout',
         },
         ...imagesTrack(),
+        ...hyperlinksTrack(),
       ],
     },
     {
@@ -114,6 +136,7 @@ export const contentTrack = (): TrackedRelationTag[] => {
           tag: null,
         },
         ...imagesTrack(),
+        ...hyperlinksTrack(),
       ],
     },
   ];

src/enums/element-type.ts

@@ -3,10 +3,12 @@ export enum ElementType {
   Image = 'Image',
   Shape = 'Generic',
   OLEObject = 'OLEObject', 
+  Hyperlink = 'Hyperlink',
 }
 
 export enum ElementSubtype {
   chart = 'chart',
   chartEx = 'chartEx',
   oleObject = 'oleObject',  
+  hyperlink = 'hyperlink',
 }