@bendyline/squisq 1.0.1 → 1.1.1

package/src/__tests__/contentContainer.test.ts

@@ -0,0 +1,282 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { MemoryContentContainer, findDocumentPath } from '../storage/ContentContainer';
+import { createMediaProviderFromContainer } from '../storage/MediaProviderFromContainer';
+import type { ContentEntry } from '../storage/ContentContainer';
+
+// ============================================
+// MemoryContentContainer
+// ============================================
+
+describe('MemoryContentContainer', () => {
+  let container: MemoryContentContainer;
+
+  beforeEach(() => {
+    container = new MemoryContentContainer();
+  });
+
+  it('readFile returns null for missing file', async () => {
+    expect(await container.readFile('missing.txt')).toBeNull();
+  });
+
+  it('writeFile and readFile round-trip', async () => {
+    const data = new TextEncoder().encode('hello world');
+    await container.writeFile('test.txt', data, 'text/plain');
+    const result = await container.readFile('test.txt');
+    expect(result).not.toBeNull();
+    expect(new TextDecoder().decode(result!)).toBe('hello world');
+  });
+
+  it('writeFile with ArrayBuffer', async () => {
+    const buf = new ArrayBuffer(4);
+    new Uint8Array(buf).set([1, 2, 3, 4]);
+    await container.writeFile('data.bin', buf);
+    const result = await container.readFile('data.bin');
+    expect(new Uint8Array(result!)).toEqual(new Uint8Array([1, 2, 3, 4]));
+  });
+
+  it('writeFile overwrites existing file', async () => {
+    await container.writeFile('f.txt', new TextEncoder().encode('first'));
+    await container.writeFile('f.txt', new TextEncoder().encode('second'));
+    const result = await container.readFile('f.txt');
+    expect(new TextDecoder().decode(result!)).toBe('second');
+  });
+
+  it('removeFile deletes a file', async () => {
+    await container.writeFile('f.txt', new TextEncoder().encode('data'));
+    await container.removeFile('f.txt');
+    expect(await container.readFile('f.txt')).toBeNull();
+  });
+
+  it('removeFile is a no-op for missing file', async () => {
+    // Should not throw
+    await container.removeFile('nonexistent.txt');
+  });
+
+  it('exists returns true for existing file', async () => {
+    await container.writeFile('f.txt', new TextEncoder().encode('data'));
+    expect(await container.exists('f.txt')).toBe(true);
+  });
+
+  it('exists returns false for missing file', async () => {
+    expect(await container.exists('missing.txt')).toBe(false);
+  });
+
+  it('listFiles returns all files', async () => {
+    await container.writeFile('a.txt', new TextEncoder().encode('a'), 'text/plain');
+    await container.writeFile('b.jpg', new Uint8Array([0xff, 0xd8]), 'image/jpeg');
+    const entries = await container.listFiles();
+    expect(entries).toHaveLength(2);
+    expect(entries.map((e) => e.path).sort()).toEqual(['a.txt', 'b.jpg']);
+  });
+
+  it('listFiles with prefix filters results', async () => {
+    await container.writeFile('index.md', new TextEncoder().encode('# Hi'));
+    await container.writeFile('images/hero.jpg', new Uint8Array([0xff]));
+    await container.writeFile('images/bg.png', new Uint8Array([0x89]));
+    await container.writeFile('audio/clip.mp3', new Uint8Array([0x49]));
+
+    const imageEntries = await container.listFiles('images/');
+    expect(imageEntries).toHaveLength(2);
+    expect(imageEntries.map((e) => e.path).sort()).toEqual(['images/bg.png', 'images/hero.jpg']);
+  });
+
+  it('listFiles reports correct size', async () => {
+    const data = new Uint8Array([1, 2, 3, 4, 5]);
+    await container.writeFile('data.bin', data);
+    const entries = await container.listFiles();
+    expect(entries[0].size).toBe(5);
+  });
+
+  it('listFiles guesses MIME type from extension', async () => {
+    await container.writeFile('photo.jpg', new Uint8Array([0xff]));
+    const entries = await container.listFiles();
+    expect(entries[0].mimeType).toBe('image/jpeg');
+  });
+
+  it('listFiles uses provided MIME type over guess', async () => {
+    await container.writeFile('data.bin', new Uint8Array([0]), 'application/custom');
+    const entries = await container.listFiles();
+    expect(entries[0].mimeType).toBe('application/custom');
+  });
+});
+
+// ============================================
+// Document discovery
+// ============================================
+
+describe('getDocumentPath', () => {
+  let container: MemoryContentContainer;
+
+  beforeEach(() => {
+    container = new MemoryContentContainer();
+  });
+
+  it('returns null for empty container', async () => {
+    expect(await container.getDocumentPath()).toBeNull();
+  });
+
+  it('finds index.md', async () => {
+    await container.writeFile('index.md', new TextEncoder().encode('# Hello'));
+    expect(await container.getDocumentPath()).toBe('index.md');
+  });
+
+  it('prefers index.md over doc.md', async () => {
+    await container.writeFile('doc.md', new TextEncoder().encode('doc'));
+    await container.writeFile('index.md', new TextEncoder().encode('index'));
+    expect(await container.getDocumentPath()).toBe('index.md');
+  });
+
+  it('prefers doc.md over document.md', async () => {
+    await container.writeFile('document.md', new TextEncoder().encode('document'));
+    await container.writeFile('doc.md', new TextEncoder().encode('doc'));
+    expect(await container.getDocumentPath()).toBe('doc.md');
+  });
+
+  it('prefers document.md over arbitrary .md', async () => {
+    await container.writeFile('readme.md', new TextEncoder().encode('readme'));
+    await container.writeFile('document.md', new TextEncoder().encode('document'));
+    expect(await container.getDocumentPath()).toBe('document.md');
+  });
+
+  it('falls back to first .md at root', async () => {
+    await container.writeFile('my-story.md', new TextEncoder().encode('story'));
+    expect(await container.getDocumentPath()).toBe('my-story.md');
+  });
+
+  it('ignores .md files in subdirectories', async () => {
+    await container.writeFile('docs/notes.md', new TextEncoder().encode('notes'));
+    expect(await container.getDocumentPath()).toBeNull();
+  });
+
+  it('ignores non-md files', async () => {
+    await container.writeFile('data.json', new TextEncoder().encode('{}'));
+    await container.writeFile('hero.jpg', new Uint8Array([0xff]));
+    expect(await container.getDocumentPath()).toBeNull();
+  });
+});
+
+describe('readDocument / writeDocument', () => {
+  let container: MemoryContentContainer;
+
+  beforeEach(() => {
+    container = new MemoryContentContainer();
+  });
+
+  it('writeDocument creates index.md by default', async () => {
+    await container.writeDocument('# Hello');
+    expect(await container.getDocumentPath()).toBe('index.md');
+    expect(await container.readDocument()).toBe('# Hello');
+  });
+
+  it('writeDocument uses custom filename', async () => {
+    await container.writeDocument('# Custom', 'story.md');
+    expect(await container.getDocumentPath()).toBe('story.md');
+    expect(await container.readDocument()).toBe('# Custom');
+  });
+
+  it('readDocument returns null for empty container', async () => {
+    expect(await container.readDocument()).toBeNull();
+  });
+});
+
+// ============================================
+// findDocumentPath (standalone)
+// ============================================
+
+describe('findDocumentPath', () => {
+  it('returns null for empty list', () => {
+    expect(findDocumentPath([])).toBeNull();
+  });
+
+  it('finds index.md from entry list', () => {
+    const entries: ContentEntry[] = [
+      { path: 'images/hero.jpg', mimeType: 'image/jpeg', size: 100 },
+      { path: 'index.md', mimeType: 'text/markdown', size: 50 },
+    ];
+    expect(findDocumentPath(entries)).toBe('index.md');
+  });
+
+  it('skips subdirectory .md files', () => {
+    const entries: ContentEntry[] = [
+      { path: 'docs/guide.md', mimeType: 'text/markdown', size: 50 },
+    ];
+    expect(findDocumentPath(entries)).toBeNull();
+  });
+});
+
+// ============================================
+// createMediaProviderFromContainer
+// ============================================
+
+describe('createMediaProviderFromContainer', () => {
+  let container: MemoryContentContainer;
+  let blobCounter = 0;
+
+  beforeEach(() => {
+    container = new MemoryContentContainer();
+    blobCounter = 0;
+    // Mock URL.createObjectURL / revokeObjectURL (not available in Node)
+    vi.stubGlobal('URL', {
+      ...URL,
+      createObjectURL: () => `blob:mock-${++blobCounter}`,
+      revokeObjectURL: vi.fn(),
+    });
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('resolveUrl returns path as-is for missing file', async () => {
+    const provider = createMediaProviderFromContainer(container);
+    expect(await provider.resolveUrl('missing.jpg')).toBe('missing.jpg');
+    provider.dispose();
+  });
+
+  it('resolveUrl returns blob URL for existing file', async () => {
+    await container.writeFile('hero.jpg', new Uint8Array([0xff, 0xd8]), 'image/jpeg');
+    const provider = createMediaProviderFromContainer(container);
+    const url = await provider.resolveUrl('hero.jpg');
+    expect(url).toMatch(/^blob:/);
+    provider.dispose();
+  });
+
+  it('resolveUrl caches blob URLs', async () => {
+    await container.writeFile('hero.jpg', new Uint8Array([0xff, 0xd8]), 'image/jpeg');
+    const provider = createMediaProviderFromContainer(container);
+    const url1 = await provider.resolveUrl('hero.jpg');
+    const url2 = await provider.resolveUrl('hero.jpg');
+    expect(url1).toBe(url2);
+    provider.dispose();
+  });
+
+  it('listMedia excludes markdown files', async () => {
+    await container.writeFile('index.md', new TextEncoder().encode('# Doc'));
+    await container.writeFile('hero.jpg', new Uint8Array([0xff]), 'image/jpeg');
+    await container.writeFile('clip.mp4', new Uint8Array([0x00]), 'video/mp4');
+
+    const provider = createMediaProviderFromContainer(container);
+    const media = await provider.listMedia();
+    expect(media).toHaveLength(2);
+    expect(media.map((m) => m.name).sort()).toEqual(['clip.mp4', 'hero.jpg']);
+    provider.dispose();
+  });
+
+  it('addMedia writes to container and returns path', async () => {
+    const provider = createMediaProviderFromContainer(container);
+    const path = await provider.addMedia('photo.png', new Uint8Array([0x89]), 'image/png');
+    expect(path).toBe('photo.png');
+    expect(await container.exists('photo.png')).toBe(true);
+    provider.dispose();
+  });
+
+  it('removeMedia deletes from container', async () => {
+    await container.writeFile('hero.jpg', new Uint8Array([0xff]), 'image/jpeg');
+    const provider = createMediaProviderFromContainer(container);
+    // Resolve first to populate cache
+    await provider.resolveUrl('hero.jpg');
+    await provider.removeMedia('hero.jpg');
+    expect(await container.exists('hero.jpg')).toBe(false);
+    provider.dispose();
+  });
+});

package/src/__tests__/markdownToDoc.test.ts

@@ -372,3 +372,99 @@ describe('template annotation in markdownToDoc', () => {
     expect(doc.blocks[0].children![0].template).toBe('chart');
   });
 });
+
+// ============================================
+// Reading-time durations & caption generation
+// ============================================
+
+describe('reading-time durations', () => {
+  it('sets block duration based on body content reading time', () => {
+    // ~50 words at 200 WPM = 15 seconds
+    const body = Array.from({ length: 50 }, (_, i) => `word${i}`).join(' ');
+    const md = parseMarkdown(`# Title\n\n${body}`);
+    const doc = markdownToDoc(md);
+
+    const block = doc.blocks[0];
+    expect(block.duration).toBeGreaterThan(5); // more than default
+    expect(block.duration).toBe(15); // 50 words / 200 WPM * 60 = 15s
+  });
+
+  it('applies minimum 3s duration for very short content', () => {
+    const md = parseMarkdown('# Title\n\nHi.');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks[0].duration).toBe(3);
+  });
+
+  it('uses defaultDuration for blocks with no body content', () => {
+    const md = parseMarkdown('# Title');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks[0].duration).toBe(5); // default
+  });
+
+  it('doc.duration sums all reading-time block durations', () => {
+    // Block A: no body → 5s default. Block B: ~20 words → 6s
+    const body = Array.from({ length: 20 }, (_, i) => `word${i}`).join(' ');
+    const md = parseMarkdown(`# A\n\n# B\n\n${body}`);
+    const doc = markdownToDoc(md);
+
+    const flat = flattenBlocks(doc.blocks);
+    expect(flat[0].duration).toBe(5); // A: no body
+    expect(flat[1].duration).toBe(6); // B: 20 words / 200 WPM * 60 = 6s
+    expect(doc.duration).toBe(11);
+  });
+});
+
+describe('caption generation', () => {
+  it('generates captions from body content', () => {
+    const md = parseMarkdown('# Title\n\nThis is the first sentence. This is the second sentence.');
+    const doc = markdownToDoc(md);
+
+    expect(doc.captions).toBeDefined();
+    expect(doc.captions!.phrases.length).toBeGreaterThanOrEqual(2);
+    expect(doc.captions!.phrases[0].text).toContain('first sentence');
+    expect(doc.captions!.phrases[1].text).toContain('second sentence');
+  });
+
+  it('caption times span the block duration', () => {
+    const md = parseMarkdown('# Section\n\nSome text here. More text follows.');
+    const doc = markdownToDoc(md);
+
+    expect(doc.captions).toBeDefined();
+    const phrases = doc.captions!.phrases;
+    // First phrase starts at block start
+    expect(phrases[0].startTime).toBe(doc.blocks[0].startTime);
+    // Last phrase ends at block end
+    const last = phrases[phrases.length - 1];
+    expect(last.endTime).toBeCloseTo(doc.blocks[0].startTime + doc.blocks[0].duration, 1);
+  });
+
+  it('does not generate captions for blocks without body content', () => {
+    const md = parseMarkdown('# A\n\n# B\n\n# C');
+    const doc = markdownToDoc(md);
+
+    // No body content anywhere → no captions
+    expect(doc.captions).toBeUndefined();
+  });
+
+  it('generates captions version and timestamp', () => {
+    const md = parseMarkdown('# Title\n\nHello world and more text.');
+    const doc = markdownToDoc(md);
+
+    expect(doc.captions!.version).toBe(1);
+    expect(doc.captions!.generatedAt).toBeTruthy();
+  });
+
+  it('caption phrases have sequential non-overlapping times', () => {
+    const md = parseMarkdown(
+      '# A\n\nFirst sentence here. Second sentence here.\n\n# B\n\nThird sentence. Fourth sentence.',
+    );
+    const doc = markdownToDoc(md);
+
+    const phrases = doc.captions!.phrases;
+    for (let i = 1; i < phrases.length; i++) {
+      expect(phrases[i].startTime).toBeGreaterThanOrEqual(phrases[i - 1].endTime - 0.001);
+    }
+  });
+});