100 lines
2.8 KiB
TypeScript
100 lines
2.8 KiB
TypeScript
import { describe, expect, it } from 'vitest';
|
|
|
|
import type { OneNoteContentBlock } from '../onenote/one/content-model.js';
|
|
import { prepareBlocksForRendering } from './page-render-budget.js';
|
|
|
|
describe('page render budget', () => {
|
|
it('stops reading blocks at the configured limit', () => {
|
|
const blocks: OneNoteContentBlock[] = Array.from(
|
|
{ length: 200_000 },
|
|
(_, index) => ({
|
|
kind: 'unsupported',
|
|
id: String(index),
|
|
sourceJcid: index,
|
|
description: 'unsupported',
|
|
})
|
|
);
|
|
|
|
const plan = prepareBlocksForRendering(blocks, { maxBlocks: 3 });
|
|
expect(plan.blocks).toHaveLength(3);
|
|
expect(plan.truncated).toBe(true);
|
|
});
|
|
|
|
it('caps rich-text runs and characters before React sees them', () => {
|
|
const block: OneNoteContentBlock = {
|
|
kind: 'text',
|
|
id: 'text',
|
|
sourceText: 'x'.repeat(1_000),
|
|
text: 'x'.repeat(1_000),
|
|
runs: Array.from({ length: 100 }, (_, index) => ({
|
|
start: index * 10,
|
|
end: index * 10 + 10,
|
|
text: 'x'.repeat(10),
|
|
style: {},
|
|
})),
|
|
paragraphStyle: {},
|
|
layout: {},
|
|
};
|
|
|
|
const plan = prepareBlocksForRendering([block], {
|
|
maxTextRuns: 3,
|
|
maxTextCharacters: 25,
|
|
});
|
|
const projected = plan.blocks[0];
|
|
expect(projected?.kind).toBe('text');
|
|
if (projected?.kind !== 'text') throw new Error('Expected text');
|
|
expect(projected.runs).toHaveLength(3);
|
|
expect(projected.runs.map((run) => run.text).join('')).toHaveLength(25);
|
|
expect(plan.truncated).toBe(true);
|
|
});
|
|
|
|
it('caps table cells and ink points independently', () => {
|
|
const table: OneNoteContentBlock = {
|
|
kind: 'table',
|
|
id: 'table',
|
|
rows: [
|
|
{
|
|
id: 'row',
|
|
cells: Array.from({ length: 100 }, (_, index) => ({
|
|
id: String(index),
|
|
blocks: [],
|
|
})),
|
|
},
|
|
],
|
|
columnWidths: [],
|
|
lockedColumns: [],
|
|
bordersVisible: true,
|
|
layout: {},
|
|
};
|
|
const ink: OneNoteContentBlock = {
|
|
kind: 'ink',
|
|
id: 'ink',
|
|
strokes: [
|
|
{
|
|
points: Array.from({ length: 100 }, (_, index) => ({
|
|
x: index,
|
|
y: index,
|
|
})),
|
|
},
|
|
],
|
|
children: [],
|
|
layout: {},
|
|
};
|
|
|
|
const plan = prepareBlocksForRendering([table, ink], {
|
|
maxTableCells: 4,
|
|
maxInkPoints: 5,
|
|
});
|
|
const projectedTable = plan.blocks[0];
|
|
const projectedInk = plan.blocks[1];
|
|
expect(projectedTable?.kind).toBe('table');
|
|
expect(projectedInk?.kind).toBe('ink');
|
|
if (projectedTable?.kind !== 'table' || projectedInk?.kind !== 'ink') {
|
|
throw new Error('Expected projected table and ink');
|
|
}
|
|
expect(projectedTable.rows[0]?.cells).toHaveLength(4);
|
|
expect(projectedInk.strokes[0]?.points).toHaveLength(5);
|
|
expect(plan.truncated).toBe(true);
|
|
});
|
|
});
|