@elisra-devops/docgen-skins 0.23.0 → 0.24.0

package/src/models/json/table/JSONTable.ts

@@ -12,6 +12,7 @@ import JSONTableRow from './JSONTableRow';
 export default class JSONTable {
   tableTemplate: Table;
   tableStyles: StyleOptions;
+  private readonly enableVerticalMerge: boolean;
 
   constructor(
     data: WIQueryResults,
@@ -29,8 +30,10 @@ export default class JSONTable {
       shading?: Shading;
       leftShading?: Shading;
       rightShading?: Shading;
-    }
+    },
+    enableVerticalMerge: boolean = false
   ) {
+    this.enableVerticalMerge = enableVerticalMerge;
     this.tableStyles = tableStyles;
     this.tableTemplate = {
       type: 'table',
@@ -106,8 +109,10 @@ export default class JSONTable {
       rows.push(row.getRow());
     });
 
-    // Apply vertical merging for grouped source cells (first row shows value; subsequent are empty)
-    this.applyVerticalMerges(rows);
+    if (this.enableVerticalMerge) {
+      // Apply vertical merging for grouped source cells (first row shows value; subsequent are empty)
+      this.applyVerticalMerges(rows);
+    }
 
     return rows;
   } //generateJsonRows
@@ -179,6 +184,17 @@ export default class JSONTable {
 
     const getCellText = (cell: any): string => {
       try {
+        const htmlRaw = String(cell?.Html?.Html || '').trim();
+        if (htmlRaw) {
+          const htmlText = htmlRaw
+            .replace(/<[^>]*>/g, ' ')
+            .replace(/&nbsp;/gi, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+          if (htmlText) {
+            return htmlText;
+          }
+        }
         const runs = cell?.Paragraphs?.[0]?.Runs || [];
         return runs.map((r: any) => (r?.text ?? '')).join('').trim();
       } catch {

package/src/test/JSONFile.test.ts

@@ -0,0 +1,59 @@
+import JSONFile from '../models/json/file/JSONFile';
+import logger from '../services/logger';
+
+jest.mock('../services/logger', () => ({
+  __esModule: true,
+  default: {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+const getMockLogger = () =>
+  logger as unknown as {
+    debug: jest.Mock;
+    info: jest.Mock;
+    warn: jest.Mock;
+    error: jest.Mock;
+  };
+
+describe('JSONFile', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('removeFileExtension returns original name when there is no dot', () => {
+    const data: any = {
+      attachmentLink: 'http://server/file',
+      attachmentFileName: 'file',
+      attachmentType: 'asEmbedded',
+      includeAttachmentContent: true,
+    };
+
+    const jsonFile = new JSONFile(data);
+    const attachment = jsonFile.getFileAttachment as any;
+
+    expect(attachment.type).toBe('File');
+    expect(attachment.name).toBe('file');
+  });
+
+  test('isPictureUri handles invalid uri and logs error', () => {
+    const data: any = {
+      attachmentLink: undefined,
+      attachmentFileName: 'file.docx',
+      attachmentType: 'asEmbedded',
+      includeAttachmentContent: true,
+    };
+
+    const jsonFile = new JSONFile(data);
+    const attachment = jsonFile.getFileAttachment as any;
+
+    expect(attachment.type).toBe('File');
+    expect(attachment.name).toBe('file');
+    expect(getMockLogger().error).toHaveBeenCalledWith(
+      expect.stringContaining('error parsing file extension for')
+    );
+  });
+});

package/src/test/JSONRun.test.ts

@@ -0,0 +1,118 @@
+import JSONRun from '../models/json/JSONRun';
+import { defaultJsonRun } from '../models/json/default';
+import logger from '../services/logger';
+
+jest.mock('../services/logger', () => ({
+  __esModule: true,
+  default: {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    silly: jest.fn(),
+  },
+}));
+
+const getMockLogger = () =>
+  logger as unknown as {
+    debug: jest.Mock;
+    info: jest.Mock;
+    warn: jest.Mock;
+    error: jest.Mock;
+    silly: jest.Mock;
+  };
+
+const baseStyles = {
+  isBold: true,
+  IsItalic: false,
+  IsUnderline: false,
+  Size: 12,
+  Uri: 'http://example.com',
+  Font: 'Arial',
+  InsertLineBreak: false,
+  InsertSpace: true,
+  InsertPageBreak: false as boolean | undefined,
+};
+
+describe('JSONRun', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('splits multi-line text into separate runs with correct line breaks', () => {
+    const value = 'line1\nline2\nline3';
+
+    const jsonRun = new JSONRun(value, { ...baseStyles });
+    const runs = jsonRun.getRun();
+
+    expect(runs).toHaveLength(3);
+
+    expect(runs[0].InsertLineBreak).toBe(true);
+    expect(runs[1].InsertLineBreak).toBe(true);
+    expect(runs[2].InsertLineBreak).toBe(baseStyles.InsertLineBreak);
+
+    runs.forEach((r) => {
+      expect(r.Bold).toBe(baseStyles.isBold);
+      expect(r.Italic).toBe(baseStyles.IsItalic);
+      expect(r.Underline).toBe(baseStyles.IsUnderline);
+      expect(r.Size).toBe(baseStyles.Size);
+      expect(r.Font).toBe(baseStyles.Font);
+      expect(r.InsertSpace).toBe(baseStyles.InsertSpace);
+    });
+  });
+
+  test('uses striphtml replaceBr callback to convert <br> to newline', () => {
+    const value = 'Hello<br>World';
+
+    const jsonRun = new JSONRun(value, { ...baseStyles });
+    const runs = jsonRun.getRun();
+
+    expect(runs).toHaveLength(1);
+    expect(runs[0].text).toContain('\n');
+  });
+
+  test('sets Uri to null when default run Uri is empty string in normal flow', () => {
+    const prevUri = defaultJsonRun.Uri;
+    defaultJsonRun.Uri = '' as any;
+
+    const jsonRun = new JSONRun('plain text', { ...baseStyles });
+    const runs = jsonRun.getRun();
+
+    runs.forEach((r) => {
+      expect(r.Uri).toBeNull();
+    });
+
+    defaultJsonRun.Uri = prevUri;
+  });
+
+  test('does not strip HTML when fieldtype is SuiteHeaderParagraphTitle', () => {
+    const value = '<b>Bold Title</b>';
+
+    const jsonRun = new JSONRun(value, { ...baseStyles }, 'SuiteHeaderParagraphTitle');
+    const runs = jsonRun.getRun();
+
+    expect(runs).toHaveLength(1);
+    expect(runs[0].text).toContain('<b>Bold Title</b>');
+  });
+
+  test('falls back to default run and logs when value cannot be split', () => {
+    const badValue: any = null;
+
+    const prevUri = defaultJsonRun.Uri;
+    defaultJsonRun.Uri = '' as any;
+
+    const jsonRun = new JSONRun(badValue, { ...baseStyles });
+    const runs = jsonRun.getRun();
+
+    expect(getMockLogger().silly).toHaveBeenCalled();
+    expect(runs).toHaveLength(1);
+    expect(runs[0].text).toBe('');
+    expect(runs[0].Bold).toBe(baseStyles.isBold);
+    expect(runs[0].Italic).toBe(baseStyles.IsItalic);
+    expect(runs[0].Underline).toBe(baseStyles.IsUnderline);
+    expect(runs[0].Size).toBe(baseStyles.Size);
+    expect(runs[0].Uri).toBeNull();
+
+    defaultJsonRun.Uri = prevUri;
+  });
+});

package/src/test/JSONTable.test.ts

@@ -0,0 +1,126 @@
+import JSONTable from '../models/json/table/JSONTable';
+
+const baseStyles = {
+  isBold: false,
+  IsItalic: false,
+  IsUnderline: false,
+  Size: 10,
+  Uri: null as string | null,
+  Font: 'Arial',
+  InsertLineBreak: false,
+  InsertSpace: false,
+};
+
+const headerStyles = {
+  ...baseStyles,
+  isBold: true,
+};
+
+const buildData = (secondColValue: string) => [
+  {
+    url: '',
+    Source: 1,
+    level: 1,
+    fields: [
+      { name: '#', value: 1, width: '8%' },
+      { name: 'Description', value: 'No description' },
+    ],
+  },
+  {
+    url: '',
+    Source: 2,
+    level: 1,
+    fields: [
+      { name: '#', value: 2, width: '8%' },
+      { name: 'Description', value: secondColValue },
+    ],
+  },
+];
+
+describe('JSONTable vertical merge behavior', () => {
+  test('uses explicit grouped-header column spans when provided', () => {
+    const table = new JSONTable(
+      [
+        {
+          url: '',
+          Source: 1,
+          level: 1,
+          fields: [
+            { name: 'Req ID', value: 1 },
+            { name: 'Title', value: 'Req' },
+            { name: 'Customer ID', value: 'C1' },
+            { name: 'Test Case ID', value: 11 },
+            { name: 'Title', value: 'TC' },
+          ],
+        },
+      ] as any,
+      headerStyles as any,
+      baseStyles as any,
+      0,
+      false,
+      false,
+      false,
+      {
+        leftLabel: 'Requirement',
+        rightLabel: 'Test Case',
+        leftColumns: 3,
+        rightColumns: 2,
+      },
+      false
+    ).getJSONTable() as any;
+
+    expect(table.Rows[0].Cells[0].gridSpan).toBe(3);
+    expect(table.Rows[0].Cells[1].gridSpan).toBe(2);
+  });
+
+  test('does not merge empty cells when vertical merge is disabled', () => {
+    const table = new JSONTable(
+      buildData('') as any,
+      headerStyles as any,
+      baseStyles as any,
+      0,
+      false,
+      false,
+      false,
+      undefined,
+      false
+    ).getJSONTable() as any;
+
+    expect(table.Rows[1].Cells[1].vMerge).toBeUndefined();
+    expect(table.Rows[2].Cells[1].vMerge).toBeUndefined();
+  });
+
+  test('merges empty cells when vertical merge is enabled', () => {
+    const table = new JSONTable(
+      buildData('') as any,
+      headerStyles as any,
+      baseStyles as any,
+      0,
+      false,
+      false,
+      false,
+      undefined,
+      true
+    ).getJSONTable() as any;
+
+    expect(table.Rows[1].Cells[1].vMerge).toBe('restart');
+    expect(table.Rows[2].Cells[1].vMerge).toBe('continue');
+  });
+
+  test('does not treat HTML cell content as empty during merge detection', () => {
+    const table = new JSONTable(
+      buildData('<div>Some Description for suite</div>') as any,
+      headerStyles as any,
+      baseStyles as any,
+      0,
+      false,
+      false,
+      false,
+      undefined,
+      true
+    ).getJSONTable() as any;
+
+    expect(table.Rows[2].Cells[1].vMerge).toBeUndefined();
+    expect(table.Rows[2].Cells[1].Html?.Html).toBe('<div>Some Description for suite</div>');
+  });
+});

package/src/test/JSONTableCell.test.ts

@@ -0,0 +1,150 @@
+import JSONTableCell from '../models/json/table/JSONTableCell';
+import logger from '../services/logger';
+
+jest.mock('../services/logger', () => ({
+  __esModule: true,
+  default: {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+const getMockLogger = () =>
+  logger as unknown as {
+    debug: jest.Mock;
+    info: jest.Mock;
+    warn: jest.Mock;
+    error: jest.Mock;
+  };
+
+const baseStyles = {
+  isBold: false,
+  IsItalic: false,
+  IsUnderline: false,
+  Size: 10,
+  Uri: null as string | null,
+  Font: 'Arial',
+  InsertLineBreak: false,
+  InsertSpace: true,
+};
+
+describe('JSONTableCell', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('creates picture attachment when value contains picture link and respects isFlattened', () => {
+    const shading = { color: 'auto', fill: 'FF0000', themeFillShade: 'BF' } as any;
+
+    const data: any = {
+      name: 'AttachmentCell',
+      value: [
+        {
+          attachmentLink: 'http://server/image.png',
+          tableCellAttachmentLink: 'http://server/image-render.png',
+          attachmentFileName: 'image.png',
+        },
+      ],
+      attachmentType: 'asEmbedded',
+      includeAttachmentContent: true,
+      width: '50%',
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, shading, true);
+    const json = cell.getJsonCell() as any;
+
+    expect(json.shading).toEqual(shading);
+    expect(json.attachments).toHaveLength(1);
+    expect(json.attachments[0]).toMatchObject({
+      type: 'Picture',
+      path: 'http://server/image-render.png',
+      name: 'image',
+      isFlattened: true,
+    });
+  });
+
+  test('creates file attachment with link flags for non-picture attachment', () => {
+    const data: any = {
+      name: 'AttachmentCell',
+      value: [
+        {
+          attachmentLink: 'http://server/doc1.pdf',
+          attachmentFileName: 'doc1.pdf',
+        },
+      ],
+      attachmentType: 'asLink',
+      includeAttachmentContent: false,
+      width: '50%',
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, undefined, true);
+    const json = cell.getJsonCell() as any;
+
+    expect(json.attachments).toHaveLength(1);
+    expect(json.attachments[0]).toMatchObject({
+      type: 'File',
+      path: 'http://server/doc1.pdf',
+      name: 'doc1',
+      isLinkedFile: true,
+      includeAttachmentContent: false,
+      isFlattened: true,
+    });
+  });
+
+  test('creates HTML cell when value contains HTML markup', () => {
+    const shading = { color: 'auto', fill: '00FF00' } as any;
+
+    const data: any = {
+      name: 'HtmlCell',
+      value: '<p>Hello</p>',
+      width: '30%',
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, shading, false);
+    const json = cell.getJsonCell() as any;
+
+    expect(json.Html).toMatchObject({
+      type: 'html',
+      Html: '<p>Hello</p>',
+      font: 'Arial',
+      fontSize: 10,
+    });
+    expect(json.shading).toEqual(shading);
+    expect(json.attachments).toHaveLength(0);
+  });
+
+  test('creates text runs when value is simple text', () => {
+    const data: any = {
+      name: 'TextCell',
+      value: 'Plain text',
+      width: '20%',
+      url: 'http://example.com/field',
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, undefined, false);
+    const json = cell.getJsonCell() as any;
+
+    expect(json.Html).toBeUndefined();
+    expect(json.attachments).toHaveLength(0);
+    expect(json.Paragraphs[0].Runs.length).toBeGreaterThan(0);
+    const text = json.Paragraphs[0].Runs.map((r: any) => r.text).join('');
+    expect(text).toContain('Plain text');
+  });
+
+  test('logs error and falls back to error run when value is invalid non-array object', () => {
+    const data: any = {
+      name: 'BadCell',
+      value: { not: 'an array' },
+      width: '10%',
+    };
+
+    const cell = new JSONTableCell(data, { ...baseStyles }, false, undefined, false);
+    const json = cell.getJsonCell() as any;
+
+    expect(getMockLogger().error).toHaveBeenCalled();
+    const text = json.Paragraphs[0].Runs.map((r: any) => r.text).join('');
+    expect(text).toContain('Docgen Error: Invalid data value');
+  });
+});

package/src/test/JSONTableRow.test.ts

@@ -0,0 +1,42 @@
+import JSONTableRow from '../models/json/table/JSONTableRow';
+import logger from '../services/logger';
+
+jest.mock('../services/logger', () => ({
+  __esModule: true,
+  default: {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+const baseStyles = {
+  isBold: false,
+  IsItalic: false,
+  IsUnderline: false,
+  Size: 10,
+  Uri: null as string | null,
+  Font: 'Arial',
+  InsertLineBreak: false,
+  InsertSpace: true,
+};
+
+describe('JSONTableRow', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('throws error when WIData has no fields', () => {
+    const data: any = {
+      url: '',
+      level: 0,
+      Source: 1,
+      // fields is intentionally missing to trigger the error path
+    };
+
+    expect(() => new JSONTableRow(data, { ...baseStyles } as any)).toThrow(
+      'no fields to add for the table row'
+    );
+  });
+});

package/src/test/JSONTestSuiteHeaderParagraph.test.ts

@@ -0,0 +1,40 @@
+import JSONTestSuiteHeaderParagraph from '../models/json/paragraph/JSONTestSuiteHeaderParagraph';
+import logger from '../services/logger';
+
+jest.mock('../services/logger', () => ({
+  __esModule: true,
+  default: {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+const baseStyles = {
+  isBold: true,
+  IsItalic: false,
+  IsUnderline: false,
+  Size: 14,
+  Uri: null as string | null,
+  Font: 'Arial',
+  InsertLineBreak: false,
+  InsertSpace: true,
+};
+
+describe('JSONTestSuiteHeaderParagraph', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('creates runs for non-title/id/description fields and sets heading level', () => {
+    const fields: any[] = [{ name: 'Custom', value: 'Value', url: 'http://example.com' }];
+
+    const paragraph = new JSONTestSuiteHeaderParagraph(fields, { ...baseStyles }, 1, 2);
+    const json = paragraph.getJSONParagraph() as any;
+
+    expect(json.type).toBe('paragraph');
+    expect(json.headingLevel).toBe(2);
+    expect(json.runs.length).toBeGreaterThan(0);
+  });
+});