@bendyline/squisq-formats 1.4.2 → 2.0.1

package/src/__tests__/convert.test.ts

@@ -5,9 +5,15 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import JSZip from 'jszip';
 import { parseMarkdown } from '@bendyline/squisq/markdown';
 import { markdownToDoc } from '@bendyline/squisq/doc';
-import { convert, ConversionError, defaultRegistry } from '../registry/index';
+import { MemoryContentContainer } from '@bendyline/squisq/storage';
+import { createTransformStyleRegistry, resolveTransformStyle } from '@bendyline/squisq/transform';
+import { convert, ConversionError, defaultRegistry, prepareConversion } from '../registry/index';
+import { zipToContainer } from '../container/index';
+import { markdownDocToPptx } from '../pptx/export';
+import { buildThemedPptx } from './pptxInferFixtures';
 
 const SAMPLE_MD = `# Round Trip
 
@@ -40,6 +46,105 @@ describe('convert error paths', () => {
       convert({ kind: 'markdown', markdown: '# hi' }, 'importonly', { registry }),
     ).rejects.toMatchObject({ name: 'ConversionError', code: 'unsupported-output' });
   });
+
+  it('normalizes importer failures to ConversionError', async () => {
+    const promise = convert({ kind: 'bytes', data: new TextEncoder().encode('not a zip') }, 'md', {
+      from: 'docx',
+    });
+    await expect(promise).rejects.toMatchObject({
+      name: 'ConversionError',
+      code: 'invalid-input',
+      format: 'docx',
+    });
+  });
+
+  it('threads cancellation to exporters and preserves the abort reason', async () => {
+    const controller = new AbortController();
+    const reason = new Error('caller cancelled conversion');
+    reason.name = 'AbortError';
+    const registry = defaultRegistry();
+    registry.register({
+      id: 'abortable',
+      label: 'Abortable',
+      mimeType: 'application/x-abortable',
+      extensions: ['.abortable'],
+      async exportDoc(_input, options) {
+        expect(options.signal).toBe(controller.signal);
+        controller.abort(reason);
+        throw new Error('must not replace the abort reason');
+      },
+    });
+
+    await expect(
+      convert({ kind: 'markdown', markdown: '# Cancel me' }, 'abortable', {
+        registry,
+        signal: controller.signal,
+      }),
+    ).rejects.toBe(reason);
+  });
+});
+
+describe('format option threading', () => {
+  it('threads CSV tableIndex and delimiter through the conversion facade', async () => {
+    const markdown =
+      '| A | B |\n|---|---|\n| first | row |\n\n| C | D |\n|---|---|\n| second | row |\n';
+    const result = await convert({ kind: 'markdown', markdown }, 'csv', {
+      formatOptions: { csv: { tableIndex: 1, delimiter: ';' } },
+    });
+    expect(new TextDecoder().decode(result.bytes)).toBe('C;D\r\nsecond;row');
+    expect(result.warnings).toEqual([]);
+  });
+
+  it('honors Markdown parse options for direct Markdown sources', async () => {
+    let captured: import('../registry/index').NormalizedInput | undefined;
+    const registry = defaultRegistry();
+    registry.register({
+      id: 'capture-md-options',
+      label: 'Capture Markdown Options',
+      mimeType: 'application/x-capture',
+      extensions: ['.capture'],
+      async exportDoc(input) {
+        captured = input;
+        return {
+          bytes: new Uint8Array(),
+          mimeType: 'application/x-capture',
+          suggestedFilename: '',
+          warnings: [],
+        };
+      },
+    });
+
+    await convert(
+      { kind: 'markdown', markdown: '---\ntitle: Hidden metadata\n---\n\n# Body' },
+      'capture-md-options',
+      {
+        registry,
+        formatOptions: { md: { parse: { frontmatter: false } } },
+      },
+    );
+
+    expect(captured?.markdownDoc?.frontmatter).toBeUndefined();
+  });
+
+  it('threads archive safety limits into OOXML importers', async () => {
+    const docx = await convert({ kind: 'markdown', markdown: '# Limited' }, 'docx');
+    await expect(
+      convert({ kind: 'bytes', data: docx.bytes }, 'md', {
+        from: 'docx',
+        formatOptions: { docx: { maxEntries: 1 } },
+      }),
+    ).rejects.toMatchObject({ code: 'invalid-input', format: 'docx' });
+  });
+
+  it('can emit DBK with STORE so strict import compression limits accept its own output', async () => {
+    const result = await convert(
+      { kind: 'markdown', markdown: `# Self-compatible DBK\n\n${'x'.repeat(16 * 1024)}` },
+      'dbk',
+      { formatOptions: { dbk: { compression: 'STORE' } } },
+    );
+    const restored = await zipToContainer(result.bytes, { maxCompressionRatio: 1.01 });
+    expect(await restored.readDocument()).toContain('Self-compatible DBK');
+  });
 });
 
 // ── round trip: md → docx → md ──────────────────────────────────────
@@ -94,6 +199,21 @@ describe('byte sniffing', () => {
     expect(text).toContain('In a container');
   });
 
+  it('DBK export snapshots the supplied source instead of stale container markdown', async () => {
+    const container = new MemoryContentContainer();
+    await container.writeDocument('# Old');
+    await container.writeFile('asset.bin', new Uint8Array([1, 2, 3]));
+
+    const result = await convert({ kind: 'markdown', markdown: '# New', container }, 'dbk');
+    const restored = await zipToContainer(result.bytes);
+    expect(await restored.readDocument()).toContain('# New');
+    expect(new Uint8Array((await restored.readFile('asset.bin'))!)).toEqual(
+      new Uint8Array([1, 2, 3]),
+    );
+    // Snapshotting must not mutate the caller's container.
+    expect(await container.readDocument()).toBe('# Old');
+  });
+
   it('disambiguates a docx zip via its content-types part', async () => {
     const docx = await convert({ kind: 'markdown', markdown: '# Word doc' }, 'docx');
     // No filename, no `from` — must read [Content_Types].xml to pick docx.
@@ -106,6 +226,113 @@ describe('byte sniffing', () => {
 // ── transform threading ─────────────────────────────────────────────
 
 describe('transform threading', () => {
+  it('normalizes and transforms once before exporting multiple targets', async () => {
+    let importCount = 0;
+    let transformLookupCount = 0;
+    const exportCounts = { first: 0, second: 0 };
+    const markers: string[] = [];
+    const exportSignals: Array<AbortSignal | undefined> = [];
+    const formats = defaultRegistry();
+    formats.register({
+      id: 'counted-input',
+      label: 'Counted input',
+      mimeType: 'application/x-counted-input',
+      extensions: ['.counted'],
+      async importDoc() {
+        importCount += 1;
+        return parseMarkdown(SAMPLE_MD);
+      },
+    });
+    for (const [id, key] of [
+      ['prepared-first', 'first'],
+      ['prepared-second', 'second'],
+    ] as const) {
+      formats.register({
+        id,
+        label: id,
+        mimeType: `application/x-${id}`,
+        extensions: [`.${key}`],
+        async exportDoc(input, options) {
+          exportCounts[key] += 1;
+          exportSignals.push(options.signal);
+          const targetOptions = options.formatOptions?.[id] as { marker?: string } | undefined;
+          markers.push(targetOptions?.marker ?? 'missing');
+          expect(input.doc.blocks.length).toBeGreaterThan(0);
+          return {
+            bytes: new TextEncoder().encode(key),
+            mimeType: `application/x-${id}`,
+            suggestedFilename: '',
+            warnings: [`${key} warning`],
+          };
+        },
+      });
+    }
+
+    const style = { ...resolveTransformStyle('magazine'), id: 'counted-transform' };
+    const backingTransforms = createTransformStyleRegistry([style]);
+    const transformRegistry = {
+      register: (candidate: typeof style) => backingTransforms.register(candidate),
+      unregister: (id: string) => backingTransforms.unregister(id),
+      get: (id: string) => {
+        transformLookupCount += 1;
+        return backingTransforms.get(id);
+      },
+      list: () => backingTransforms.list(),
+    };
+    const overall = new AbortController();
+    const prepared = await prepareConversion(
+      {
+        kind: 'bytes',
+        data: new TextEncoder().encode('count me once'),
+        filename: 'source.counted',
+      },
+      {
+        registry: formats,
+        from: 'counted-input',
+        transformStyle: 'counted-transform',
+        transformRegistry,
+        signal: overall.signal,
+      },
+    );
+    const first = await prepared.convert('prepared-first', {
+      formatOptions: { 'prepared-first': { marker: 'one' } },
+    });
+    const target = new AbortController();
+    const second = await prepared.convert('prepared-second', {
+      signal: target.signal,
+      formatOptions: { 'prepared-second': { marker: 'two' } },
+    });
+
+    expect(importCount).toBe(1);
+    expect(transformLookupCount).toBe(1);
+    expect(exportCounts).toEqual({ first: 1, second: 1 });
+    expect(markers).toEqual(['one', 'two']);
+    expect(exportSignals[0]).toBe(overall.signal);
+    expect(exportSignals[1]?.aborted).toBe(false);
+    expect(first.suggestedFilename).toBe('source.first');
+    expect(second.suggestedFilename).toBe('source.second');
+    expect(first.warnings).toContain('first warning');
+    expect(second.warnings).toContain('second warning');
+
+    await expect(prepared.convert('missing-target')).rejects.toMatchObject({
+      name: 'ConversionError',
+      code: 'unknown-format',
+      format: 'missing-target',
+    });
+    const targetReason = new Error('cancel target export');
+    target.abort(targetReason);
+    expect(exportSignals[1]?.reason).toBe(targetReason);
+    await expect(prepared.convert('prepared-first', { signal: target.signal })).rejects.toBe(
+      targetReason,
+    );
+    const overallReason = new Error('cancel prepared conversion');
+    overall.abort(overallReason);
+    await expect(
+      prepared.convert('prepared-first', { signal: new AbortController().signal }),
+    ).rejects.toBe(overallReason);
+    expect(exportCounts.first).toBe(1);
+  });
+
   it('applies a transform style before handing off to the exporter', async () => {
     // A capture format records the NormalizedInput it receives, letting us
     // observe that the transform ran without depending on any converter.
@@ -140,6 +367,40 @@ describe('transform threading', () => {
     // markdownDoc is re-derived from the transformed Doc.
     expect(captured!.markdownDoc).toBeDefined();
   });
+
+  it('resolves transform ids only from the explicitly supplied registry', async () => {
+    let captured: import('../registry/index').NormalizedInput | undefined;
+    const formats = defaultRegistry();
+    formats.register({
+      id: 'capture-custom-transform',
+      label: 'Capture Custom Transform',
+      mimeType: 'application/x-capture',
+      extensions: ['.cap'],
+      async exportDoc(input) {
+        captured = input;
+        return {
+          bytes: new Uint8Array([1]),
+          mimeType: 'application/x-capture',
+          suggestedFilename: '',
+          warnings: [],
+        };
+      },
+    });
+    const custom = {
+      ...resolveTransformStyle('minimal'),
+      id: 'tenant-transform',
+      suggestedThemeId: 'cinematic',
+    };
+    const transformRegistry = createTransformStyleRegistry([custom]);
+
+    await convert({ kind: 'markdown', markdown: SAMPLE_MD }, 'capture-custom-transform', {
+      registry: formats,
+      transformStyle: 'tenant-transform',
+      transformRegistry,
+    });
+
+    expect(captured?.doc.themeId).toBe('cinematic');
+  });
 });
 
 // ── doc-kind source ─────────────────────────────────────────────────
@@ -178,9 +439,57 @@ describe('suggestedFilename', () => {
     const out = await convert({ kind: 'markdown', markdown: '# t' }, 'md');
     expect(out.suggestedFilename).toBe('document.md');
   });
+
+  it('uses only the basename for Windows-style input paths', async () => {
+    const out = await convert(
+      {
+        kind: 'bytes',
+        data: new TextEncoder().encode('# Windows'),
+        filename: 'C:\\docs\\report.md',
+      },
+      'md',
+    );
+    expect(out.suggestedFilename).toBe('report.md');
+  });
 });
 
 // sanity: ConversionError is exported and usable
+// ── pptx theme/layout inference threading ───────────────────────────
+
+describe('pptx import inference threading (default ON)', () => {
+  it('carries an inferred theme through convert() by default', async () => {
+    const deck = await markdownDocToPptx(parseMarkdown('# Hi\n\nBody.\n'), {});
+    const result = await convert({ kind: 'bytes', data: deck, filename: 'deck.pptx' }, 'md');
+    const md = new TextDecoder().decode(result.bytes);
+    expect(md).toContain('squisq-theme: custom-office-theme');
+    expect(md).toContain('squisq-custom-themes');
+  });
+
+  it('omits inference with formatOptions.pptx.inferTheme=false', async () => {
+    const deck = await markdownDocToPptx(parseMarkdown('# Hi\n\nBody.\n'), {});
+    const result = await convert({ kind: 'bytes', data: deck, filename: 'deck.pptx' }, 'md', {
+      formatOptions: { pptx: { inferTheme: false, inferLayouts: false } },
+    });
+    const md = new TextDecoder().decode(result.bytes);
+    expect(md).not.toContain('squisq-theme');
+    expect(md).not.toContain('squisq-custom-themes');
+  });
+
+  it('end-to-end: inferred theme colors reach a downstream docx export', async () => {
+    // Distinctive fixture theme (bg #fdfdf8, text #1a1a2e) → pptx → docx.
+    const result = await convert(
+      { kind: 'bytes', data: await buildThemedPptx(), filename: 'deck.pptx' },
+      'docx',
+    );
+    const zip = await JSZip.loadAsync(result.bytes);
+    let text = '';
+    for (const name of Object.keys(zip.files)) {
+      if (/\.(xml|rels)$/i.test(name)) text += await zip.files[name]!.async('string');
+    }
+    expect(text.toLowerCase()).toContain('1a1a2e');
+  });
+});
+
 it('exports ConversionError', () => {
   expect(new ConversionError('conversion-failed', 'x')).toBeInstanceOf(Error);
 });

package/src/__tests__/epub.test.ts

@@ -5,7 +5,7 @@
  * image embedding, metadata, and stylesheet generation.
  */
 
-import { describe, it, expect } from 'vitest';
+import { afterEach, describe, it, expect, vi } from 'vitest';
 import JSZip from 'jszip';
 import type { MarkdownDocument, MarkdownBlockNode } from '@bendyline/squisq/markdown';
 import { markdownDocToEpub } from '../epub/export';
@@ -65,6 +65,10 @@ async function exportAndUnzip(doc: MarkdownDocument, options?: EpubExportOptions
 // ============================================
 
 describe('markdownDocToEpub', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
   describe('EPUB structure', () => {
     it('produces a valid ZIP with required EPUB files', async () => {
       const doc = makeDoc([heading(1, 'Title'), paragraph('Content')]);
@@ -175,6 +179,15 @@ describe('markdownDocToEpub', () => {
       expect(ch).toContain('<a href="https://example.com">click</a>');
     });
 
+    it('strips executable link schemes while preserving link text', async () => {
+      const doc = makeDoc([heading(1, 'Test'), linkParagraph('click', 'javascript:alert(1)')]);
+      const zip = await exportAndUnzip(doc);
+      const ch = await zip.file('OEBPS/chapters/chapter-001.xhtml')!.async('string');
+      expect(ch).not.toContain('javascript:');
+      expect(ch).not.toContain('<a ');
+      expect(ch).toContain('click');
+    });
+
     it('renders code blocks with language class', async () => {
       const doc = makeDoc([heading(1, 'Test'), codeBlock('const x = 1;', 'javascript')]);
       const zip = await exportAndUnzip(doc);
@@ -298,6 +311,17 @@ describe('markdownDocToEpub', () => {
       expect(opf).toContain('image/png');
     });
 
+    it('flattens backslash-separated image paths to safe archive basenames', async () => {
+      const source = '..\\private\\logo.png';
+      const doc = makeDoc([heading(1, 'Test'), imageParagraph('Logo', source)]);
+      const zip = await exportAndUnzip(doc, {
+        images: new Map([[source, new Uint8Array([0x89]).buffer]]),
+      });
+
+      expect(zip.file('OEBPS/images/logo.png')).toBeTruthy();
+      expect(Object.keys(zip.files).some((path) => path.includes('\\'))).toBe(false);
+    });
+
     it('embeds cover image with cover-image property', async () => {
       const coverData = new Uint8Array([0xff, 0xd8]).buffer;
       const doc = makeDoc([heading(1, 'Test')]);
@@ -307,6 +331,23 @@ describe('markdownDocToEpub', () => {
       const opf = await zip.file('OEBPS/content.opf')!.async('string');
       expect(opf).toContain('cover-image');
     });
+
+    it('does not overwrite a document image whose basename collides with the cover', async () => {
+      const documentImage = new Uint8Array([1, 2, 3]).buffer;
+      const coverImage = new Uint8Array([0x89, 0x50, 0x4e, 0x47]).buffer;
+      const doc = makeDoc([heading(1, 'Test'), imageParagraph('Inline cover', 'cover.png')]);
+      const zip = await exportAndUnzip(doc, {
+        images: new Map([['cover.png', documentImage]]),
+        coverImage,
+      });
+
+      expect(await zip.file('OEBPS/images/cover.png')!.async('uint8array')).toEqual(
+        new Uint8Array(documentImage),
+      );
+      expect(zip.file('OEBPS/images/cover-2.png')).toBeTruthy();
+      const opf = await zip.file('OEBPS/content.opf')!.async('string');
+      expect(opf).toContain('href="images/cover-2.png"');
+    });
   });
 
   describe('metadata', () => {
@@ -356,6 +397,18 @@ describe('markdownDocToEpub', () => {
       expect(opf).toContain('urn:uuid:');
     });
 
+    it('falls back to getRandomValues when randomUUID is unavailable', async () => {
+      vi.stubGlobal('crypto', {
+        getRandomValues<T extends ArrayBufferView>(array: T): T {
+          new Uint8Array(array.buffer, array.byteOffset, array.byteLength).fill(0xab);
+          return array;
+        },
+      });
+      const zip = await exportAndUnzip(makeDoc([heading(1, 'Test')]));
+      const opf = await zip.file('OEBPS/content.opf')!.async('string');
+      expect(opf).toMatch(/urn:uuid:abababab-abab-4bab-abab-abababababab/);
+    });
+
     it('uses frontmatter title as fallback', async () => {
       const doc = makeDoc([heading(1, 'Intro')], { title: 'Frontmatter Title' });
       const zip = await exportAndUnzip(doc);
@@ -446,6 +499,54 @@ describe('markdownDocToEpub', () => {
       expect(zip.file('OEBPS/audio/body.mp3')).toBeTruthy();
     });
 
+    it('deduplicates colliding audio basenames without overwriting either segment', async () => {
+      const doc = makeDoc([
+        heading(1, 'One'),
+        paragraph('First'),
+        heading(1, 'Two'),
+        paragraph('Second'),
+      ]);
+      const segments = [
+        { src: 'a/narration.mp3', name: 'one', duration: 10, startTime: 0 },
+        { src: 'b/narration.mp3', name: 'two', duration: 10, startTime: 10 },
+      ];
+      const zip = await exportAndUnzip(doc, {
+        audio: new Map([
+          ['a/narration.mp3', new Uint8Array([1]).buffer],
+          ['b/narration.mp3', new Uint8Array([2]).buffer],
+        ]),
+        audioSegments: segments,
+        totalDuration: 20,
+      });
+
+      expect(zip.file('OEBPS/audio/narration.mp3')).toBeTruthy();
+      expect(zip.file('OEBPS/audio/narration-2.mp3')).toBeTruthy();
+      const firstSmil = await zip.file('OEBPS/chapters/chapter-001.smil')!.async('string');
+      const secondSmil = await zip.file('OEBPS/chapters/chapter-002.smil')!.async('string');
+      expect(firstSmil).toContain('narration.mp3');
+      expect(secondSmil).toContain('narration-2.mp3');
+    });
+
+    it('writes one manifest item when multiple segments reuse one audio source', async () => {
+      const doc = makeDoc([
+        heading(1, 'One'),
+        paragraph('First'),
+        heading(1, 'Two'),
+        paragraph('Second'),
+      ]);
+      const zip = await exportAndUnzip(doc, {
+        audio: new Map([['narration.mp3', new Uint8Array([1, 2, 3]).buffer]]),
+        audioSegments: [
+          { src: 'narration.mp3', name: 'one', duration: 10, startTime: 0 },
+          { src: 'narration.mp3', name: 'two', duration: 10, startTime: 10 },
+        ],
+        totalDuration: 20,
+      });
+      const opf = await zip.file('OEBPS/content.opf')!.async('string');
+
+      expect(opf.match(/href="audio\/narration\.mp3"/g)).toHaveLength(1);
+    });
+
     it('generates SMIL overlay files for each chapter', async () => {
       const doc = makeDoc([
         heading(1, 'Intro'),

package/src/__tests__/html.test.ts

@@ -8,6 +8,7 @@
 import { describe, it, expect } from 'vitest';
 import JSZip from 'jszip';
 import type { Doc, Block, ImageLayer } from '@bendyline/squisq/schemas';
+import { compileTheme, createThemeRegistry } from '@bendyline/squisq/schemas';
 import { docToHtml, docToHtmlZip, collectImagePaths } from '../html/index';
 import { inferMimeType, arrayBufferToBase64DataUrl, extractFilename } from '../html/imageUtils';
 
@@ -95,6 +96,16 @@ describe('arrayBufferToBase64DataUrl', () => {
     expect(result).toMatch(/^data:text\/plain;base64,/);
     expect(result).toBe('data:text/plain;base64,aGVsbG8=');
   });
+
+  it('encodes large buffers correctly across chunk boundaries', () => {
+    const bytes = Uint8Array.from({ length: 100_003 }, (_, index) => index % 251);
+    const result = arrayBufferToBase64DataUrl(bytes.buffer, 'application/octet-stream');
+    const decoded = Uint8Array.from(atob(result.split(',')[1]), (character) =>
+      character.charCodeAt(0),
+    );
+
+    expect(decoded).toEqual(bytes);
+  });
 });
 
 describe('extractFilename', () => {
@@ -225,6 +236,41 @@ describe('docToHtml', () => {
     expect(html).toContain('test-doc');
   });
 
+  it('embeds an explicitly registered theme selected by the document', () => {
+    const external = compileTheme({
+      id: 'tenant-brand',
+      name: 'External Tenant Brand',
+      seedColors: { primary: '#6633cc' },
+    });
+    const html = docToHtml(makeDoc({ themeId: external.id }), {
+      playerScript: MOCK_PLAYER_SCRIPT,
+      themeRegistry: createThemeRegistry([external]),
+    });
+
+    expect(html).toContain('External Tenant Brand');
+    expect(html).toContain('\\"themeId\\":\\"tenant-brand\\"');
+  });
+
+  it('keeps a document-scoped theme ahead of the explicit registry', () => {
+    const inline = compileTheme({
+      id: 'tenant-brand',
+      name: 'Inline Tenant Brand',
+      seedColors: { primary: '#112233' },
+    });
+    const external = compileTheme({
+      id: 'tenant-brand',
+      name: 'External Tenant Brand',
+      seedColors: { primary: '#6633cc' },
+    });
+    const html = docToHtml(makeDoc({ themeId: inline.id, customThemes: [inline] }), {
+      playerScript: MOCK_PLAYER_SCRIPT,
+      themeRegistry: createThemeRegistry([external]),
+    });
+
+    expect(html).toContain('Inline Tenant Brand');
+    expect(html).not.toContain('External Tenant Brand');
+  });
+
   it('calls SquisqPlayer.mount', () => {
     const doc = makeDoc();
     const html = docToHtml(doc, { playerScript: MOCK_PLAYER_SCRIPT });
@@ -310,6 +356,22 @@ describe('docToHtmlZip', () => {
     expect(html).not.toContain(MOCK_PLAYER_SCRIPT);
   });
 
+  it('embeds a caller-owned theme selected by the document', async () => {
+    const external = compileTheme({
+      id: 'tenant-zip-brand',
+      name: 'Tenant ZIP Brand',
+      seedColors: { primary: '#224466' },
+    });
+    const blob = await docToHtmlZip(makeDoc({ themeId: external.id }), {
+      playerScript: MOCK_PLAYER_SCRIPT,
+      themeRegistry: createThemeRegistry([external]),
+    });
+
+    const zip = await JSZip.loadAsync(await blobToUint8Array(blob));
+    const html = await zip.file('index.html')!.async('text');
+    expect(html).toContain('Tenant ZIP Brand');
+  });
+
   it('preserves the original image path inside the zip', async () => {
     // Direct `<img src="folder/file.png">` references in the rendered HTML
     // resolve only if the zip mirrors the doc's path layout — flattening