@bendyline/squisq-formats 2.0.1 → 2.2.0

package/src/__tests__/ooxmlCancellation.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { inferThemeFromFile } from '../infer/index';
-import { getPartXml, openPackage } from '../ooxml/reader';
-import { inspectPptxLayouts } from '../pptx/layouts';
-import { prepareZipInput } from '../shared/zipEntryCount';
-import { buildThemedPptx } from './pptxInferFixtures';
-
-function blockingBlob(onRead: () => void): Blob {
-  const blob = {
-    size: 128,
-    slice: () => blob,
-    arrayBuffer: () => {
-      onRead();
-      return new Promise<ArrayBuffer>(() => undefined);
-    },
-  };
-  return blob as unknown as Blob;
-}
-
-describe('OOXML cancellation', () => {
-  it('preserves the exact reason while theme inference reads Blob input', async () => {
-    let markStarted: (() => void) | undefined;
-    const started = new Promise<void>((resolve) => {
-      markStarted = resolve;
-    });
-    const controller = new AbortController();
-    const reason = new Error('stop inference');
-    const pending = inferThemeFromFile(
-      blockingBlob(() => markStarted?.()),
-      {
-        signal: controller.signal,
-      },
-    );
-
-    await started;
-    controller.abort(reason);
-
-    await expect(pending).rejects.toBe(reason);
-  });
-
-  it('preserves the exact reason while layout inspection opens Blob input', async () => {
-    let markStarted: (() => void) | undefined;
-    const started = new Promise<void>((resolve) => {
-      markStarted = resolve;
-    });
-    const controller = new AbortController();
-    const reason = new Error('stop layout inspection');
-    const pending = inspectPptxLayouts(
-      blockingBlob(() => markStarted?.()),
-      {
-        signal: controller.signal,
-      },
-    );
-
-    await started;
-    controller.abort(reason);
-
-    await expect(pending).rejects.toBe(reason);
-  });
-
-  it('propagates package cancellation through later OOXML part traversal', async () => {
-    const controller = new AbortController();
-    const pkg = await openPackage(await buildThemedPptx(), { signal: controller.signal });
-    const reason = new Error('stop OOXML traversal');
-    controller.abort(reason);
-
-    await expect(getPartXml(pkg, 'ppt/presentation.xml')).rejects.toBe(reason);
-  });
-
-  it('handles a synchronously re-entrant FileReader abort exactly once', async () => {
-    const previous = globalThis.FileReader;
-    let abortCalls = 0;
-    class ReentrantFileReader {
-      result: ArrayBuffer | null = null;
-      error: DOMException | null = null;
-      onload: ((event: ProgressEvent<FileReader>) => void) | null = null;
-      onerror: ((event: ProgressEvent<FileReader>) => void) | null = null;
-      onabort: ((event: ProgressEvent<FileReader>) => void) | null = null;
-      readAsArrayBuffer(): void {
-        // Remain pending until the caller aborts.
-      }
-
-      abort(): void {
-        abortCalls += 1;
-        this.onabort?.({} as ProgressEvent<FileReader>);
-      }
-    }
-    Object.defineProperty(globalThis, 'FileReader', {
-      configurable: true,
-      writable: true,
-      value: ReentrantFileReader,
-    });
-
-    const blobLike = { size: 1, slice: () => blobLike } as unknown as Blob;
-    const controller = new AbortController();
-    const reason = new Error('stop FileReader');
-    try {
-      const pending = prepareZipInput(blobLike, controller.signal);
-      controller.abort(reason);
-      await expect(pending).rejects.toBe(reason);
-      expect(abortCalls).toBe(1);
-    } finally {
-      if (previous === undefined) Reflect.deleteProperty(globalThis, 'FileReader');
-      else {
-        Object.defineProperty(globalThis, 'FileReader', {
-          configurable: true,
-          writable: true,
-          value: previous,
-        });
-      }
-    }
-  });
-});

package/src/__tests__/ooxmlThemeReader.test.ts

@@ -1,92 +0,0 @@
-/**
- * Tests for the shared OOXML theme reader: clrScheme slot resolution
- * (srgbClr / sysClr / fallbacks) and fontScheme parsing.
- */
-
-import { describe, expect, it } from 'vitest';
-import { NS_DRAWINGML } from '../ooxml/namespaces';
-import { parseThemeXml } from '../ooxml/themeReader';
-import { buildThemeXml } from './pptxInferFixtures';
-
-function parse(xml: string): Document {
-  return new DOMParser().parseFromString(xml, 'application/xml');
-}
-
-describe('parseThemeXml', () => {
-  it('reads srgbClr slots, theme name, and latin fonts', () => {
-    const theme = parseThemeXml(parse(buildThemeXml({ name: 'Ion' })));
-    expect(theme.name).toBe('Ion');
-    expect(theme.colors).toMatchObject({
-      dk1: '#1a1a2e',
-      lt1: '#fdfdf8',
-      dk2: '#30304a',
-      lt2: '#efefe4',
-      accent1: '#4472c4',
-      accent6: '#70ad47',
-      hlink: '#0563c1',
-    });
-    expect(theme.fonts).toEqual({ majorLatin: 'Playfair Display', minorLatin: 'Aptos' });
-  });
-
-  it('prefers sysClr lastClr when present', () => {
-    const xml = buildThemeXml({
-      dk1: '<a:sysClr val="windowText" lastClr="0B0B0B"/>',
-      lt1: '<a:sysClr val="window" lastClr="FAFAFA"/>',
-    });
-    const theme = parseThemeXml(parse(xml));
-    expect(theme.colors?.dk1).toBe('#0b0b0b');
-    expect(theme.colors?.lt1).toBe('#fafafa');
-  });
-
-  it('resolves windowText/window sysClr without lastClr', () => {
-    const xml = buildThemeXml({
-      dk1: '<a:sysClr val="windowText"/>',
-      lt1: '<a:sysClr val="window"/>',
-    });
-    const theme = parseThemeXml(parse(xml));
-    expect(theme.colors?.dk1).toBe('#000000');
-    expect(theme.colors?.lt1).toBe('#ffffff');
-  });
-
-  it('falls back with a warning for unknown sysClr values', () => {
-    const xml = buildThemeXml({ dk1: '<a:sysClr val="btnFace"/>' });
-    const theme = parseThemeXml(parse(xml));
-    expect(theme.colors?.dk1).toBe('#000000');
-    expect(theme.warnings.some((w) => w.includes('dk1'))).toBe(true);
-  });
-
-  it('drops unresolvable accent slots with warnings', () => {
-    // accent list of 2 → accent3..6 slots missing entirely.
-    const xml = buildThemeXml({ accents: ['112233', '445566'] });
-    const theme = parseThemeXml(parse(xml));
-    expect(theme.colors?.accent1).toBe('#112233');
-    expect(theme.colors?.accent2).toBe('#445566');
-    expect(theme.colors?.accent3).toBeUndefined();
-    expect(theme.warnings.some((w) => w.includes('accent3'))).toBe(true);
-  });
-
-  it('handles a missing fontScheme', () => {
-    const theme = parseThemeXml(parse(buildThemeXml({ omitFontScheme: true })));
-    expect(theme.fonts).toBeUndefined();
-    expect(theme.warnings.some((w) => w.includes('fontScheme'))).toBe(true);
-  });
-
-  it('treats an empty typeface as absent', () => {
-    const xml =
-      `<a:theme xmlns:a="${NS_DRAWINGML}" name="T"><a:themeElements>` +
-      `<a:fontScheme name="T">` +
-      `<a:majorFont><a:latin typeface=""/></a:majorFont>` +
-      `<a:minorFont><a:latin typeface="Georgia"/></a:minorFont>` +
-      `</a:fontScheme></a:themeElements></a:theme>`;
-    const theme = parseThemeXml(parse(xml));
-    expect(theme.fonts).toEqual({ minorLatin: 'Georgia' });
-    expect(theme.warnings.some((w) => w.includes('majorFont'))).toBe(true);
-  });
-
-  it('reports a theme with no clrScheme', () => {
-    const xml = `<a:theme xmlns:a="${NS_DRAWINGML}" name="Empty"><a:themeElements/></a:theme>`;
-    const theme = parseThemeXml(parse(xml));
-    expect(theme.colors).toBeUndefined();
-    expect(theme.warnings.some((w) => w.includes('clrScheme'))).toBe(true);
-  });
-});

package/src/__tests__/pdfExport.test.ts

@@ -1,322 +0,0 @@
-/**
- * Tests for PDF export: markdownDocToPdf, docToPdf.
- *
- * Exports various MarkdownDocuments to PDF, then re-opens the
- * resulting ArrayBuffers with pdf-lib to verify structure/metadata.
- */
-
-import { describe, it, expect } from 'vitest';
-import { PDFDocument } from 'pdf-lib';
-import type {
-  MarkdownDocument,
-  MarkdownHeading,
-  MarkdownParagraph,
-  MarkdownList,
-  MarkdownListItem,
-  MarkdownTable,
-  MarkdownTableRow,
-  MarkdownTableCell,
-  MarkdownCodeBlock,
-  MarkdownBlockquote,
-  MarkdownThematicBreak,
-  MarkdownText,
-  MarkdownStrong,
-  MarkdownEmphasis,
-  MarkdownInlineCode,
-  MarkdownLink,
-} from '@bendyline/squisq/markdown';
-
-import { markdownDocToPdf, docToPdf } from '../pdf/export';
-import type { Doc } from '@bendyline/squisq/schemas';
-
-// ============================================
-// Helpers
-// ============================================
-
-async function exportAndLoad(
-  doc: MarkdownDocument,
-  options?: Parameters<typeof markdownDocToPdf>[1],
-) {
-  const buffer = await markdownDocToPdf(doc, options);
-  expect(buffer).toBeInstanceOf(ArrayBuffer);
-  expect(buffer.byteLength).toBeGreaterThan(0);
-  return PDFDocument.load(buffer);
-}
-
-function text(value: string): MarkdownText {
-  return { type: 'text', value };
-}
-
-// ============================================
-// Basic Structure
-// ============================================
-
-describe('markdownDocToPdf', () => {
-  it('produces a valid PDF for an empty document', async () => {
-    const doc: MarkdownDocument = { type: 'document', children: [] };
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBeGreaterThanOrEqual(1);
-  });
-
-  it('sets title and author metadata', async () => {
-    const doc: MarkdownDocument = { type: 'document', children: [] };
-    const pdf = await exportAndLoad(doc, { title: 'Test Title', author: 'Test Author' });
-    expect(pdf.getTitle()).toBe('Test Title');
-    expect(pdf.getAuthor()).toBe('Test Author');
-  });
-
-  it('renders a single paragraph', async () => {
-    const doc: MarkdownDocument = {
-      type: 'document',
-      children: [
-        {
-          type: 'paragraph',
-          children: [text('Hello, World!')],
-        } as MarkdownParagraph,
-      ],
-    };
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBe(1);
-  });
-
-  it('renders headings at various depths', async () => {
-    const children: MarkdownHeading[] = [1, 2, 3, 4, 5, 6].map((d) => ({
-      type: 'heading',
-      depth: d as 1 | 2 | 3 | 4 | 5 | 6,
-      children: [text(`Heading Level ${d}`)],
-    }));
-    const doc: MarkdownDocument = { type: 'document', children };
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBeGreaterThanOrEqual(1);
-  });
-
-  it('renders inline formatting (bold, italic, code)', async () => {
-    const doc: MarkdownDocument = {
-      type: 'document',
-      children: [
-        {
-          type: 'paragraph',
-          children: [
-            text('Normal '),
-            { type: 'strong', children: [text('bold')] } as MarkdownStrong,
-            text(' '),
-            { type: 'emphasis', children: [text('italic')] } as MarkdownEmphasis,
-            text(' '),
-            { type: 'inlineCode', value: 'code' } as MarkdownInlineCode,
-          ],
-        } as MarkdownParagraph,
-      ],
-    };
-    // Should not throw
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBe(1);
-  });
-
-  it('renders a link', async () => {
-    const doc: MarkdownDocument = {
-      type: 'document',
-      children: [
-        {
-          type: 'paragraph',
-          children: [
-            text('See '),
-            {
-              type: 'link',
-              url: 'https://example.com',
-              children: [text('Example')],
-            } as MarkdownLink,
-          ],
-        } as MarkdownParagraph,
-      ],
-    };
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBe(1);
-  });
-
-  it('renders unordered and ordered lists', async () => {
-    const unordered: MarkdownList = {
-      type: 'list',
-      ordered: false,
-      children: [
-        {
-          type: 'listItem',
-          children: [{ type: 'paragraph', children: [text('Apple')] } as MarkdownParagraph],
-        } as MarkdownListItem,
-        {
-          type: 'listItem',
-          children: [{ type: 'paragraph', children: [text('Banana')] } as MarkdownParagraph],
-        } as MarkdownListItem,
-      ],
-    };
-    const ordered: MarkdownList = {
-      type: 'list',
-      ordered: true,
-      children: [
-        {
-          type: 'listItem',
-          children: [{ type: 'paragraph', children: [text('First')] } as MarkdownParagraph],
-        } as MarkdownListItem,
-        {
-          type: 'listItem',
-          children: [{ type: 'paragraph', children: [text('Second')] } as MarkdownParagraph],
-        } as MarkdownListItem,
-      ],
-    };
-    const doc: MarkdownDocument = { type: 'document', children: [unordered, ordered] };
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBeGreaterThanOrEqual(1);
-  });
-
-  it('renders a code block', async () => {
-    const doc: MarkdownDocument = {
-      type: 'document',
-      children: [
-        {
-          type: 'code',
-          value: 'function hello() {\n  return "world";\n}',
-        } as MarkdownCodeBlock,
-      ],
-    };
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBe(1);
-  });
-
-  it('renders a blockquote', async () => {
-    const doc: MarkdownDocument = {
-      type: 'document',
-      children: [
-        {
-          type: 'blockquote',
-          children: [{ type: 'paragraph', children: [text('Quoted text')] } as MarkdownParagraph],
-        } as MarkdownBlockquote,
-      ],
-    };
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBe(1);
-  });
-
-  it('renders a table', async () => {
-    const row = (cells: string[], isHeader: boolean): MarkdownTableRow => ({
-      type: 'tableRow',
-      children: cells.map(
-        (c) =>
-          ({
-            type: 'tableCell',
-            isHeader,
-            children: [text(c)],
-          }) as MarkdownTableCell,
-      ),
-    });
-
-    const doc: MarkdownDocument = {
-      type: 'document',
-      children: [
-        {
-          type: 'table',
-          children: [
-            row(['Name', 'Age', 'City'], true),
-            row(['Alice', '30', 'NYC'], false),
-            row(['Bob', '25', 'LA'], false),
-          ],
-        } as MarkdownTable,
-      ],
-    };
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBeGreaterThanOrEqual(1);
-  });
-
-  it('renders a thematic break', async () => {
-    const doc: MarkdownDocument = {
-      type: 'document',
-      children: [
-        { type: 'paragraph', children: [text('Before')] } as MarkdownParagraph,
-        { type: 'thematicBreak' } as MarkdownThematicBreak,
-        { type: 'paragraph', children: [text('After')] } as MarkdownParagraph,
-      ],
-    };
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBe(1);
-  });
-
-  it('uses A4 page size when specified', async () => {
-    const doc: MarkdownDocument = {
-      type: 'document',
-      children: [{ type: 'paragraph', children: [text('A4 page')] } as MarkdownParagraph],
-    };
-    const pdf = await exportAndLoad(doc, { pageSize: 'a4' });
-    const page = pdf.getPage(0);
-    const { width, height } = page.getSize();
-    // A4 is approximately 595 × 842
-    expect(width).toBeCloseTo(595.28, 0);
-    expect(height).toBeCloseTo(841.89, 0);
-  });
-
-  it('paginates long documents', async () => {
-    const children: MarkdownParagraph[] = [];
-    // Each paragraph is a few lines — 100 paragraphs should overflow a page
-    for (let i = 0; i < 100; i++) {
-      children.push({
-        type: 'paragraph',
-        children: [text(`Paragraph number ${i + 1}. This is some body text to fill the page.`)],
-      });
-    }
-    const doc: MarkdownDocument = { type: 'document', children };
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBeGreaterThan(1);
-  });
-
-  it('handles nested lists', async () => {
-    const inner: MarkdownList = {
-      type: 'list',
-      ordered: false,
-      children: [
-        {
-          type: 'listItem',
-          children: [{ type: 'paragraph', children: [text('Nested item')] } as MarkdownParagraph],
-        } as MarkdownListItem,
-      ],
-    };
-    const outer: MarkdownList = {
-      type: 'list',
-      ordered: false,
-      children: [
-        {
-          type: 'listItem',
-          children: [
-            { type: 'paragraph', children: [text('Outer item')] } as MarkdownParagraph,
-            inner,
-          ],
-        } as MarkdownListItem,
-      ],
-    };
-    const doc: MarkdownDocument = { type: 'document', children: [outer] };
-    const pdf = await exportAndLoad(doc);
-    expect(pdf.getPageCount()).toBeGreaterThanOrEqual(1);
-  });
-});
-
-// ============================================
-// docToPdf convenience wrapper
-// ============================================
-
-describe('docToPdf', () => {
-  it('converts a Doc object to PDF', async () => {
-    const doc: Doc = {
-      articleId: 'test-article',
-      duration: 3,
-      audio: { segments: [] },
-      blocks: [
-        {
-          id: 'block-1',
-          startTime: 0,
-          duration: 3,
-          audioSegment: 0,
-          template: 'title',
-        },
-      ],
-    };
-    const buffer = await docToPdf(doc);
-    expect(buffer).toBeInstanceOf(ArrayBuffer);
-    expect(buffer.byteLength).toBeGreaterThan(0);
-  });
-});