docxmlater 10.0.2 → 10.0.3

package/dist/zip/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/zip/types.ts"],"names":[],"mappings":";;;AAuCa,QAAA,mBAAmB,GAA+B;IAC7D,aAAa,EAAE,EAAE;IACjB,SAAS,EAAE,GAAG;CACf,CAAC;AA4CW,QAAA,mBAAmB,GAAG;IACjC,qBAAqB;IACrB,aAAa;IACb,mBAAmB;CACX,CAAC;AAKE,QAAA,UAAU,GAAG;IACxB,aAAa,EAAE,qBAAqB;IACpC,IAAI,EAAE,aAAa;IACnB,QAAQ,EAAE,mBAAmB;IAC7B,aAAa,EAAE,8BAA8B;IAC7C,MAAM,EAAE,iBAAiB;IACzB,SAAS,EAAE,oBAAoB;IAC/B,cAAc,EAAE,+BAA+B;IAC/C,QAAQ,EAAE,mBAAmB;IAC7B,UAAU,EAAE,oBAAoB;IAChC,KAAK,EAAE,uBAAuB;IAC9B,UAAU,EAAE,mBAAmB;IAC/B,SAAS,EAAE,kBAAkB;IAC7B,SAAS,EAAE,aAAa;IACxB,SAAS,EAAE,oBAAoB;IAC/B,QAAQ,EAAE,mBAAmB;IAC7B,iBAAiB,EAAE,2BAA2B;IAC9C,YAAY,EAAE,sBAAsB;IACpC,mBAAmB,EAAE,6BAA6B;IAClD,YAAY,EAAE,sBAAsB;CAC5B,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/zip/types.ts"],"names":[],"mappings":";;;AAuCa,QAAA,mBAAmB,GAA+B;IAC7D,aAAa,EAAE,EAAE;IACjB,SAAS,EAAE,GAAG;CACf,CAAC;AA4CW,QAAA,mBAAmB,GAAG;IACjC,qBAAqB;IACrB,aAAa;IACb,mBAAmB;CACX,CAAC;AAKE,QAAA,UAAU,GAAG;IACxB,aAAa,EAAE,qBAAqB;IACpC,IAAI,EAAE,aAAa;IACnB,QAAQ,EAAE,mBAAmB;IAC7B,aAAa,EAAE,8BAA8B;IAC7C,MAAM,EAAE,iBAAiB;IACzB,SAAS,EAAE,oBAAoB;IAC/B,cAAc,EAAE,+BAA+B;IAC/C,QAAQ,EAAE,mBAAmB;IAC7B,UAAU,EAAE,oBAAoB;IAChC,KAAK,EAAE,uBAAuB;IAC9B,UAAU,EAAE,mBAAmB;IAC/B,SAAS,EAAE,kBAAkB;IAC7B,SAAS,EAAE,aAAa;IACxB,SAAS,EAAE,oBAAoB;IAC/B,QAAQ,EAAE,mBAAmB;IAC7B,iBAAiB,EAAE,2BAA2B;IAC9C,YAAY,EAAE,sBAAsB;IACpC,mBAAmB,EAAE,6BAA6B;IAClD,YAAY,EAAE,sBAAsB;CAC5B,CAAC","sourcesContent":["/**\r\n * Types and interfaces for ZIP archive handling\r\n */\r\n\r\n/**\r\n * Represents a file within a ZIP archive\r\n */\r\nexport interface ZipFile {\r\n  /** The path of the file within the archive */\r\n  path: string;\r\n  /** The content of the file (string for text, Buffer for binary) */\r\n  content: string | Buffer;\r\n  /** Whether the content is binary */\r\n  isBinary: boolean;\r\n  /** File size in bytes */\r\n  size: number;\r\n  /** Last modified date */\r\n  date?: Date;\r\n}\r\n\r\n/**\r\n * Size limit configuration for document loading\r\n */\r\nexport interface SizeLimitOptions {\r\n  /**\r\n   * Size in MB at which to show a warning (default: 50 MB)\r\n   * Set to 0 to disable warnings\r\n   */\r\n  warningSizeMB?: number;\r\n  /**\r\n   * Maximum size in MB to load (default: 150 MB)\r\n   * Set to 0 to disable the limit (not recommended)\r\n   */\r\n  maxSizeMB?: number;\r\n}\r\n\r\n/**\r\n * Default size limits for document loading\r\n */\r\nexport const DEFAULT_SIZE_LIMITS: Required<SizeLimitOptions> = {\r\n  warningSizeMB: 50,\r\n  maxSizeMB: 150,\r\n};\r\n\r\n/**\r\n * Options for loading a DOCX file\r\n */\r\nexport interface LoadOptions {\r\n  /** Whether to validate the DOCX structure on load */\r\n  validate?: boolean;\r\n  /** Whether to load files lazily */\r\n  lazy?: boolean;\r\n  /** Size limit configuration (warning and max size thresholds) */\r\n  sizeLimits?: SizeLimitOptions;\r\n}\r\n\r\n/**\r\n * Options for saving a DOCX file\r\n */\r\nexport interface SaveOptions {\r\n  /** Compression level (0-9, where 0 is no compression and 9 is maximum) */\r\n  compression?: number;\r\n  /** Whether to validate the DOCX structure before save */\r\n  validate?: boolean;\r\n}\r\n\r\n/**\r\n * Options for adding files to the archive\r\n */\r\nexport interface AddFileOptions {\r\n  /** Whether the content is binary */\r\n  binary?: boolean;\r\n  /** Compression level for this specific file */\r\n  compression?: number;\r\n  /** Last modified date */\r\n  date?: Date;\r\n}\r\n\r\n/**\r\n * Map of file paths to their contents\r\n */\r\nexport type FileMap = Map<string, ZipFile>;\r\n\r\n/**\r\n * Required files for a valid DOCX structure\r\n */\r\nexport const REQUIRED_DOCX_FILES = [\r\n  '[Content_Types].xml',\r\n  '_rels/.rels',\r\n  'word/document.xml'\r\n] as const;\r\n\r\n/**\r\n * Common DOCX file paths\r\n */\r\nexport const DOCX_PATHS = {\r\n  CONTENT_TYPES: '[Content_Types].xml',\r\n  RELS: '_rels/.rels',\r\n  DOCUMENT: 'word/document.xml',\r\n  DOCUMENT_RELS: 'word/_rels/document.xml.rels',\r\n  STYLES: 'word/styles.xml',\r\n  NUMBERING: 'word/numbering.xml',\r\n  NUMBERING_RELS: 'word/_rels/numbering.xml.rels',\r\n  SETTINGS: 'word/settings.xml',\r\n  FONT_TABLE: 'word/fontTable.xml',\r\n  THEME: 'word/theme/theme1.xml',\r\n  CORE_PROPS: 'docProps/core.xml',\r\n  APP_PROPS: 'docProps/app.xml',\r\n  MEDIA_DIR: 'word/media/',\r\n  FOOTNOTES: 'word/footnotes.xml',\r\n  ENDNOTES: 'word/endnotes.xml',\r\n  COMMENTS_EXTENDED: 'word/commentsExtended.xml',\r\n  COMMENTS_IDS: 'word/commentsIds.xml',\r\n  COMMENTS_EXTENSIBLE: 'word/commentsExtensible.xml',\r\n  WEB_SETTINGS: 'word/webSettings.xml',\r\n} as const;\r\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docxmlater",
-  "version": "10.0.2",
+  "version": "10.0.3",
   "description": "A comprehensive DOCX editing framework for creating, reading, and manipulating Microsoft Word documents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,7 +14,18 @@
     "prepublishOnly": "npm run clean && npm run build",
     "docs:metrics": "echo 'Source Files:' && find src -name '*.ts' | wc -l && echo 'Test Files:' && find tests -name '*.test.ts' | wc -l && echo 'Lines of Code:' && find src -name '*.ts' -exec wc -l {} + | tail -1",
     "docs:check": "echo 'Checking documentation...' && ls -1 README.md CHANGELOG.md 2>/dev/null || echo 'Missing documentation files'",
-    "test-list-arch": "ts-node examples/test-list-formatting-architecture.ts"
+    "test-list-arch": "ts-node examples/test-list-formatting-architecture.ts",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "typecheck": "tsc --noEmit",
+    "dev:watch": "tsc --watch",
+    "dev:push": "nodemon --watch dist --ext js,d.ts --exec \"yalc push --changed\"",
+    "dev:full": "concurrently \"npm run dev:watch\" \"npm run dev:push\"",
+    "knip": "knip",
+    "knip:fix": "knip --fix",
+    "depcruise": "depcruise src --config",
+    "size": "size-limit"
   },
   "keywords": [
     "docx",
@@ -41,6 +52,7 @@
   "homepage": "https://github.com/ItMeDiaTech/docXMLater#readme",
   "files": [
     "dist",
+    "src",
     "README.md",
     "LICENSE"
   ],
@@ -48,15 +60,33 @@
     "node": ">=18.0.0"
   },
   "devDependencies": {
+    "@size-limit/file": "^12.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^25.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "@xarsh/ooxml-validator": "^0.1.10",
+    "concurrently": "^9.2.1",
+    "dependency-cruiser": "^17.3.8",
+    "eslint": "^10.0.1",
     "jest": "^30.2.0",
+    "knip": "^5.84.1",
+    "nodemon": "^3.1.14",
+    "prettier": "^3.8.1",
     "rimraf": "^6.1.0",
+    "size-limit": "^12.0.0",
     "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
-    "typescript": "^5.7.2"
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.56.0"
   },
   "dependencies": {
     "jszip": "^3.10.1"
-  }
+  },
+  "size-limit": [
+    {
+      "path": "dist/index.js",
+      "limit": "150 KB"
+    }
+  ]
 }

package/src/__tests__/helper-methods.test.ts

@@ -0,0 +1,512 @@
+/**
+ * Tests for all new helper methods added to docxmlater
+ * Tests Document, Paragraph, Table, and Image helper methods
+ */
+
+import { Document } from '../core/Document';
+import { Paragraph } from '../elements/Paragraph';
+import { Table } from '../elements/Table';
+import { Image } from '../elements/Image';
+
+describe('Document Helper Methods', () => {
+  let doc: Document;
+
+  beforeEach(() => {
+    doc = Document.create();
+  });
+
+  describe('findText', () => {
+    it('should find text in paragraphs', () => {
+      const para = doc.createParagraph('Hello world, this is a test document with some text.');
+
+      const results = doc.findText('test');
+      expect(results).toHaveLength(1);
+      expect(results[0]?.text).toBe('test');
+      expect(results[0]?.paragraph).toBe(para);
+    });
+
+    it('should find text with case sensitivity', () => {
+      doc.createParagraph('Hello World');
+
+      const results1 = doc.findText('world', { caseSensitive: false });
+      expect(results1).toHaveLength(1);
+
+      const results2 = doc.findText('world', { caseSensitive: true });
+      expect(results2).toHaveLength(0);
+
+      const results3 = doc.findText('World', { caseSensitive: true });
+      expect(results3).toHaveLength(1);
+    });
+
+    it('should find whole words only', () => {
+      doc.createParagraph('This is testing a test case');
+
+      const results1 = doc.findText('test', { wholeWord: false });
+      expect(results1).toHaveLength(2); // "testing" and "test"
+
+      const results2 = doc.findText('test', { wholeWord: true });
+      expect(results2).toHaveLength(1); // only "test"
+    });
+
+    it('should find text in tables', () => {
+      const table = doc.createTable(2, 2);
+      table.getCell(0, 0)?.createParagraph('Cell with test text');
+
+      const results = doc.findText('test');
+      expect(results).toHaveLength(1);
+    });
+  });
+
+  describe('replaceText', () => {
+    it('should replace text in paragraphs', () => {
+      const para = doc.createParagraph('Hello world');
+
+      const count = doc.replaceText('world', 'universe');
+      expect(count).toBe(1);
+      expect(para.getText()).toBe('Hello universe');
+    });
+
+    it('should replace multiple occurrences', () => {
+      const para = doc.createParagraph('test test test');
+
+      const count = doc.replaceText('test', 'example');
+      expect(count).toBe(3);
+      expect(para.getText()).toBe('example example example');
+    });
+
+    it('should replace with case sensitivity', () => {
+      const para = doc.createParagraph('Test test TEST');
+
+      const count1 = doc.replaceText('test', 'example', { caseSensitive: true });
+      expect(count1).toBe(1);
+      expect(para.getText()).toBe('Test example TEST');
+
+      para.setText('Test test TEST');
+      const count2 = doc.replaceText('test', 'example', { caseSensitive: false });
+      expect(count2).toBe(3);
+      expect(para.getText()).toBe('example example example');
+    });
+
+    it('should replace whole words only', () => {
+      const para = doc.createParagraph('testing test tested');
+
+      const count = doc.replaceText('test', 'exam', { wholeWord: true });
+      expect(count).toBe(1);
+      expect(para.getText()).toBe('testing exam tested');
+    });
+  });
+
+  describe('getWordCount', () => {
+    it('should count words in paragraphs', () => {
+      doc.createParagraph('Hello world');
+      doc.createParagraph('This is a test');
+
+      expect(doc.getWordCount()).toBe(6);
+    });
+
+    it('should count words in tables', () => {
+      doc.createParagraph('Hello world');
+      const table = doc.createTable(2, 2);
+      table.getCell(0, 0)?.createParagraph('Table cell text');
+
+      expect(doc.getWordCount()).toBe(5); // 2 + 3
+    });
+
+    it('should handle empty paragraphs', () => {
+      doc.createParagraph('');
+      doc.createParagraph('Hello');
+      doc.createParagraph('');
+
+      expect(doc.getWordCount()).toBe(1);
+    });
+  });
+
+  describe('getCharacterCount', () => {
+    it('should count characters with spaces', () => {
+      doc.createParagraph('Hello world');
+
+      expect(doc.getCharacterCount(true)).toBe(11);
+    });
+
+    it('should count characters without spaces', () => {
+      doc.createParagraph('Hello world');
+
+      expect(doc.getCharacterCount(false)).toBe(10);
+    });
+
+    it('should count characters in tables', () => {
+      doc.createParagraph('Test');
+      const table = doc.createTable(1, 1);
+      table.getCell(0, 0)?.createParagraph('Cell');
+
+      expect(doc.getCharacterCount(true)).toBe(8); // 4 + 4
+    });
+  });
+
+  describe('removeParagraph', () => {
+    it('should remove paragraph by object', () => {
+      const para1 = doc.createParagraph('First');
+      const para2 = doc.createParagraph('Second');
+      const para3 = doc.createParagraph('Third');
+
+      expect(doc.getParagraphCount()).toBe(3);
+
+      const removed = doc.removeParagraph(para2);
+      expect(removed).toBe(true);
+      expect(doc.getParagraphCount()).toBe(2);
+      expect(doc.getParagraphs()).toEqual([para1, para3]);
+    });
+
+    it('should remove paragraph by index', () => {
+      doc.createParagraph('First');
+      doc.createParagraph('Second');
+      doc.createParagraph('Third');
+
+      const removed = doc.removeParagraph(1);
+      expect(removed).toBe(true);
+      expect(doc.getParagraphCount()).toBe(2);
+      expect(doc.getParagraphs()[1]?.getText()).toBe('Third');
+    });
+
+    it('should return false for invalid index', () => {
+      doc.createParagraph('First');
+
+      expect(doc.removeParagraph(-1)).toBe(false);
+      expect(doc.removeParagraph(5)).toBe(false);
+    });
+  });
+
+  describe('removeTable', () => {
+    it('should remove table by object', () => {
+      const table1 = doc.createTable(1, 1);
+      const table2 = doc.createTable(2, 2);
+
+      expect(doc.getTableCount()).toBe(2);
+
+      const removed = doc.removeTable(table1);
+      expect(removed).toBe(true);
+      expect(doc.getTableCount()).toBe(1);
+      expect(doc.getTables()[0]).toBe(table2);
+    });
+
+    it('should remove table by index', () => {
+      doc.createTable(1, 1);
+      doc.createTable(2, 2);
+
+      const removed = doc.removeTable(0);
+      expect(removed).toBe(true);
+      expect(doc.getTableCount()).toBe(1);
+    });
+  });
+
+  describe('insertParagraphAt', () => {
+    it('should insert paragraph at specific position', () => {
+      doc.createParagraph('First');
+      doc.createParagraph('Third');
+
+      const para2 = new Paragraph();
+      para2.addText('Second');
+      doc.insertParagraphAt(1, para2);
+
+      expect(doc.getParagraphCount()).toBe(3);
+      expect(doc.getParagraphs()[1]).toBe(para2);
+    });
+
+    it('should handle edge cases', () => {
+      doc.createParagraph('First');
+
+      const para0 = new Paragraph();
+      para0.addText('Zero');
+      doc.insertParagraphAt(-1, para0);
+      expect(doc.getParagraphs()[0]).toBe(para0);
+
+      const paraLast = new Paragraph();
+      paraLast.addText('Last');
+      doc.insertParagraphAt(100, paraLast);
+      expect(doc.getParagraphs()[doc.getParagraphCount() - 1]).toBe(paraLast);
+    });
+  });
+
+  describe('getHyperlinks', () => {
+    it('should find hyperlinks in paragraphs', () => {
+      doc.createParagraph();
+      // We'd need to properly create a hyperlink through the document's relationship manager
+      // For now, we'll just test that the method returns an empty array
+
+      const links = doc.getHyperlinks();
+      expect(links).toEqual([]);
+    });
+  });
+
+  describe('getBookmarks', () => {
+    it('should find bookmarks in paragraphs', () => {
+      const para = doc.createParagraph('Text');
+      const bookmark = doc.createBookmark('test-bookmark');
+      para.addBookmark(bookmark);
+
+      const bookmarks = doc.getBookmarks();
+      expect(bookmarks).toHaveLength(1);
+      expect(bookmarks[0]?.bookmark).toBe(bookmark);
+      expect(bookmarks[0]?.paragraph).toBe(para);
+    });
+  });
+
+  describe('getImages', () => {
+    it('should return all images', async () => {
+      // This would need actual image files to test properly
+      const images = doc.getImages();
+      expect(images).toEqual([]);
+    });
+  });
+
+  describe('setLanguage/getLanguage', () => {
+    it('should set and get document language', () => {
+      expect(doc.getLanguage()).toBeUndefined();
+
+      doc.setLanguage('en-US');
+      expect(doc.getLanguage()).toBe('en-US');
+
+      doc.setLanguage('es-ES');
+      expect(doc.getLanguage()).toBe('es-ES');
+    });
+  });
+});
+
+describe('Paragraph Helper Methods', () => {
+  let para: Paragraph;
+
+  beforeEach(() => {
+    para = new Paragraph();
+  });
+
+  describe('getWordCount', () => {
+    it('should count words in paragraph', () => {
+      para.addText('Hello world, this is a test');
+      expect(para.getWordCount()).toBe(6);
+    });
+
+    it('should handle empty paragraph', () => {
+      expect(para.getWordCount()).toBe(0);
+    });
+
+    it('should handle multiple runs', () => {
+      para.addText('Hello ');
+      para.addText('world');
+      expect(para.getWordCount()).toBe(2);
+    });
+  });
+
+  describe('getLength', () => {
+    it('should count characters with spaces', () => {
+      para.addText('Hello world');
+      expect(para.getLength(true)).toBe(11);
+    });
+
+    it('should count characters without spaces', () => {
+      para.addText('Hello world');
+      expect(para.getLength(false)).toBe(10);
+    });
+  });
+
+  describe('clone', () => {
+    it('should create a deep copy of paragraph', () => {
+      para.addText('Hello', { bold: true });
+      para.addText(' world', { italic: true });
+      para.setAlignment('center');
+      para.setSpaceBefore(240);
+
+      const cloned = para.clone();
+
+      expect(cloned).not.toBe(para);
+      expect(cloned.getText()).toBe('Hello world');
+      expect(cloned.getFormatting().alignment).toBe('center');
+      expect(cloned.getFormatting().spacing?.before).toBe(240);
+      expect(cloned.getRuns()).toHaveLength(2);
+      expect(cloned.getRuns()[0]?.getFormatting().bold).toBe(true);
+      expect(cloned.getRuns()[1]?.getFormatting().italic).toBe(true);
+    });
+  });
+
+  describe('setBorder', () => {
+    it('should set paragraph borders', () => {
+      para.setBorder({
+        top: { style: 'single', size: 4, color: '000000' },
+        bottom: { style: 'double', size: 8, color: 'FF0000' }
+      });
+
+      const formatting = para.getFormatting() as any;
+      expect(formatting.borders).toBeDefined();
+      expect(formatting.borders.top.style).toBe('single');
+      expect(formatting.borders.bottom.color).toBe('FF0000');
+    });
+  });
+
+  describe('setShading', () => {
+    it('should set paragraph shading', () => {
+      para.setShading({
+        fill: 'FFFF00',
+        pattern: 'solid'
+      });
+
+      const formatting = para.getFormatting() as any;
+      expect(formatting.shading).toBeDefined();
+      expect(formatting.shading.fill).toBe('FFFF00');
+      expect(formatting.shading.pattern).toBe('solid');
+    });
+  });
+
+  describe('setTabs', () => {
+    it('should set tab stops', () => {
+      para.setTabs([
+        { position: 720, val: 'left' },
+        { position: 1440, val: 'center', leader: 'dot' }
+      ]);
+
+      const formatting = para.getFormatting() as any;
+      expect(formatting.tabs).toBeDefined();
+      expect(formatting.tabs).toHaveLength(2);
+      expect(formatting.tabs[0].position).toBe(720);
+      expect(formatting.tabs[1].leader).toBe('dot');
+    });
+  });
+});
+
+describe('Table Helper Methods', () => {
+  let table: Table;
+
+  beforeEach(() => {
+    table = new Table(3, 3);
+  });
+
+  describe('removeRow', () => {
+    it('should remove row at index', () => {
+      expect(table.getRowCount()).toBe(3);
+
+      const removed = table.removeRow(1);
+      expect(removed).toBe(true);
+      expect(table.getRowCount()).toBe(2);
+    });
+
+    it('should return false for invalid index', () => {
+      expect(table.removeRow(-1)).toBe(false);
+      expect(table.removeRow(10)).toBe(false);
+    });
+  });
+
+  describe('insertRow', () => {
+    it('should insert row at position', () => {
+      const row = table.insertRow(1);
+
+      expect(table.getRowCount()).toBe(4);
+      expect(table.getRow(1)).toBe(row);
+    });
+
+    it('should create row with correct column count', () => {
+      const row = table.insertRow(0);
+
+      expect(row.getCellCount()).toBe(3);
+    });
+  });
+
+  describe('addColumn', () => {
+    it('should add column to all rows', () => {
+      table.addColumn();
+
+      expect(table.getColumnCount()).toBe(4);
+      for (const row of table.getRows()) {
+        expect(row.getCellCount()).toBe(4);
+      }
+    });
+
+    it('should add column at specific position', () => {
+      table.getCell(0, 1)?.createParagraph('Middle');
+
+      table.addColumn(1);
+
+      expect(table.getColumnCount()).toBe(4);
+      expect(table.getCell(0, 2)?.getText()).toBe('Middle');
+    });
+  });
+
+  describe('removeColumn', () => {
+    it('should remove column from all rows', () => {
+      const removed = table.removeColumn(1);
+
+      expect(removed).toBe(true);
+      expect(table.getColumnCount()).toBe(2);
+      for (const row of table.getRows()) {
+        expect(row.getCellCount()).toBe(2);
+      }
+    });
+
+    it('should return false for invalid index', () => {
+      expect(table.removeColumn(-1)).toBe(false);
+      expect(table.removeColumn(10)).toBe(false);
+    });
+  });
+
+  describe('getColumnCount', () => {
+    it('should return maximum column count', () => {
+      expect(table.getColumnCount()).toBe(3);
+    });
+
+    it('should return 0 for empty table', () => {
+      const emptyTable = new Table();
+      expect(emptyTable.getColumnCount()).toBe(0);
+    });
+  });
+
+  describe('setColumnWidths', () => {
+    it('should set column widths', () => {
+      table.setColumnWidths([2880, 1440, null]);
+
+      const formatting = table.getFormatting();
+      expect(formatting.tableGrid).toEqual([2880, 1440, undefined]);
+    });
+  });
+});
+
+describe('Image Helper Methods', () => {
+  describe('setAltText/getAltText', () => {
+    it('should set and get alt text', async () => {
+      // Create a simple test image buffer
+      const imageBuffer = Buffer.from([0x89, 0x50, 0x4e, 0x47]); // PNG header
+      const image = await Image.fromBuffer(imageBuffer);
+
+      expect(image.getAltText()).toBe('Image');
+
+      image.setAltText('A test image');
+      expect(image.getAltText()).toBe('A test image');
+    });
+  });
+
+  describe('rotate/getRotation', () => {
+    it('should set and get rotation', async () => {
+      const imageBuffer = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+      const image = await Image.fromBuffer(imageBuffer);
+
+      expect(image.getRotation()).toBe(0);
+
+      image.rotate(90);
+      expect(image.getRotation()).toBe(90);
+
+      image.rotate(450); // Should normalize to 90
+      expect(image.getRotation()).toBe(90);
+
+      image.rotate(-90); // Should normalize to 270
+      expect(image.getRotation()).toBe(270);
+    });
+
+    it('should swap dimensions on 90/270 degree rotation', async () => {
+      const imageBuffer = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+      const image = await Image.fromBuffer(imageBuffer, { width: 1000, height: 2000 });
+
+      const originalWidth = image.getWidth();
+      const originalHeight = image.getHeight();
+
+      image.rotate(90);
+      expect(image.getWidth()).toBe(originalHeight);
+      expect(image.getHeight()).toBe(originalWidth);
+    });
+  });
+});