mirror of
https://github.com/makeplane/plane.git
synced 2026-02-24 20:20:49 +01:00
733 lines
21 KiB
TypeScript
733 lines
21 KiB
TypeScript
/**
|
|
* Copyright (c) 2023-present Plane Software, Inc. and contributors
|
|
* SPDX-License-Identifier: AGPL-3.0-only
|
|
* See the LICENSE file for details.
|
|
*/
|
|
|
|
import { describe, it, expect } from "vitest";
|
|
import { PDFParse } from "pdf-parse";
|
|
import { renderPlaneDocToPdfBuffer } from "@/lib/pdf";
|
|
import type { TipTapDocument, PDFExportMetadata } from "@/lib/pdf";
|
|
|
|
const PDF_HEADER = "%PDF-";
|
|
|
|
/**
|
|
* Helper to extract text content from a PDF buffer
|
|
*/
|
|
async function extractPdfText(buffer: Buffer): Promise<string> {
|
|
const uint8 = new Uint8Array(buffer);
|
|
const parser = new PDFParse(uint8);
|
|
const result = await parser.getText();
|
|
return result.pages.map((p) => p.text).join("\n");
|
|
}
|
|
|
|
describe("PDF Rendering Integration", () => {
|
|
describe("renderPlaneDocToPdfBuffer", () => {
|
|
it("should render empty document to valid PDF", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
|
|
expect(buffer).toBeInstanceOf(Buffer);
|
|
expect(buffer.length).toBeGreaterThan(0);
|
|
expect(buffer.toString("ascii", 0, 5)).toBe(PDF_HEADER);
|
|
});
|
|
|
|
it("should render document with title and verify content", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Hello World" }],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc, {
|
|
title: "Test Document",
|
|
});
|
|
|
|
expect(buffer).toBeInstanceOf(Buffer);
|
|
expect(buffer.toString("ascii", 0, 5)).toBe(PDF_HEADER);
|
|
|
|
const text = await extractPdfText(buffer);
|
|
expect(text).toContain("Hello World");
|
|
// Title is rendered in PDF content when provided
|
|
expect(text).toContain("Test Document");
|
|
});
|
|
|
|
it("should render heading nodes and verify text", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "heading",
|
|
attrs: { level: 1 },
|
|
content: [{ type: "text", text: "Main Heading" }],
|
|
},
|
|
{
|
|
type: "heading",
|
|
attrs: { level: 2 },
|
|
content: [{ type: "text", text: "Subheading" }],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("Main Heading");
|
|
expect(text).toContain("Subheading");
|
|
});
|
|
|
|
it("should render paragraph with text and verify content", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "This is a test paragraph with some content." }],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("This is a test paragraph with some content.");
|
|
});
|
|
|
|
it("should render bullet list with all items", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "bulletList",
|
|
content: [
|
|
{
|
|
type: "listItem",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "First item" }],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "listItem",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Second item" }],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "listItem",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Third item" }],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("First item");
|
|
expect(text).toContain("Second item");
|
|
expect(text).toContain("Third item");
|
|
// Bullet points should be present
|
|
expect(text).toContain("•");
|
|
});
|
|
|
|
it("should render ordered list with numbers", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "orderedList",
|
|
content: [
|
|
{
|
|
type: "listItem",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Step one" }],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "listItem",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Step two" }],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("Step one");
|
|
expect(text).toContain("Step two");
|
|
// Numbers should be present
|
|
expect(text).toMatch(/1\./);
|
|
expect(text).toMatch(/2\./);
|
|
});
|
|
|
|
it("should render task list with task text", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "taskList",
|
|
content: [
|
|
{
|
|
type: "taskItem",
|
|
attrs: { checked: true },
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Completed task" }],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "taskItem",
|
|
attrs: { checked: false },
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Pending task" }],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("Completed task");
|
|
expect(text).toContain("Pending task");
|
|
});
|
|
|
|
it("should render code block with code content", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "codeBlock",
|
|
content: [
|
|
{ type: "text", text: "const greeting = 'Hello';\n" },
|
|
{ type: "text", text: "console.log(greeting);" },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("const greeting");
|
|
expect(text).toContain("console.log");
|
|
});
|
|
|
|
it("should render blockquote with quoted text", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "blockquote",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "This is a quoted text." }],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("This is a quoted text.");
|
|
});
|
|
|
|
it("should render table with all cell content", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "table",
|
|
content: [
|
|
{
|
|
type: "tableRow",
|
|
content: [
|
|
{
|
|
type: "tableHeader",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Header 1" }],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "tableHeader",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Header 2" }],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "tableRow",
|
|
content: [
|
|
{
|
|
type: "tableCell",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Cell 1" }],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "tableCell",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Cell 2" }],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("Header 1");
|
|
expect(text).toContain("Header 2");
|
|
expect(text).toContain("Cell 1");
|
|
expect(text).toContain("Cell 2");
|
|
});
|
|
|
|
it("should render horizontal rule with surrounding text", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Before rule" }],
|
|
},
|
|
{ type: "horizontalRule" },
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "After rule" }],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("Before rule");
|
|
expect(text).toContain("After rule");
|
|
});
|
|
|
|
it("should render text with marks (bold, italic) preserving content", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [
|
|
{ type: "text", text: "Normal " },
|
|
{
|
|
type: "text",
|
|
text: "bold",
|
|
marks: [{ type: "bold" }],
|
|
},
|
|
{ type: "text", text: " and " },
|
|
{
|
|
type: "text",
|
|
text: "italic",
|
|
marks: [{ type: "italic" }],
|
|
},
|
|
{ type: "text", text: " text." },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("Normal");
|
|
expect(text).toContain("bold");
|
|
expect(text).toContain("italic");
|
|
expect(text).toContain("text.");
|
|
});
|
|
|
|
it("should render link marks with link text", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [
|
|
{ type: "text", text: "Click " },
|
|
{
|
|
type: "text",
|
|
text: "here",
|
|
marks: [{ type: "link", attrs: { href: "https://example.com" } }],
|
|
},
|
|
{ type: "text", text: " to visit." },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("Click");
|
|
expect(text).toContain("here");
|
|
expect(text).toContain("to visit");
|
|
});
|
|
});
|
|
|
|
describe("page options", () => {
|
|
it("should support different page sizes and verify content renders", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Page size test content" }],
|
|
},
|
|
],
|
|
};
|
|
|
|
const a4Buffer = await renderPlaneDocToPdfBuffer(doc, { pageSize: "A4" });
|
|
const letterBuffer = await renderPlaneDocToPdfBuffer(doc, { pageSize: "LETTER" });
|
|
|
|
const a4Text = await extractPdfText(a4Buffer);
|
|
const letterText = await extractPdfText(letterBuffer);
|
|
|
|
expect(a4Text).toContain("Page size test content");
|
|
expect(letterText).toContain("Page size test content");
|
|
// Different page sizes should produce different PDF sizes
|
|
expect(a4Buffer.length).not.toBe(letterBuffer.length);
|
|
});
|
|
|
|
it("should support landscape orientation and verify content", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Landscape content here" }],
|
|
},
|
|
],
|
|
};
|
|
|
|
const portraitBuffer = await renderPlaneDocToPdfBuffer(doc, { pageOrientation: "portrait" });
|
|
const landscapeBuffer = await renderPlaneDocToPdfBuffer(doc, { pageOrientation: "landscape" });
|
|
|
|
const portraitText = await extractPdfText(portraitBuffer);
|
|
const landscapeText = await extractPdfText(landscapeBuffer);
|
|
|
|
expect(portraitText).toContain("Landscape content here");
|
|
expect(landscapeText).toContain("Landscape content here");
|
|
expect(portraitBuffer.length).not.toBe(landscapeBuffer.length);
|
|
});
|
|
|
|
it("should include author metadata in PDF", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Document content" }],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc, {
|
|
author: "Test Author",
|
|
});
|
|
|
|
// Verify PDF is valid and contains content
|
|
expect(buffer).toBeInstanceOf(Buffer);
|
|
expect(buffer.toString("ascii", 0, 5)).toBe(PDF_HEADER);
|
|
// Author metadata is embedded in PDF info dict (checked via raw bytes)
|
|
const pdfString = buffer.toString("latin1");
|
|
expect(pdfString).toContain("/Author");
|
|
});
|
|
|
|
it("should include subject metadata in PDF", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Document content" }],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc, {
|
|
subject: "Technical Documentation",
|
|
});
|
|
|
|
// Verify PDF is valid
|
|
expect(buffer).toBeInstanceOf(Buffer);
|
|
expect(buffer.toString("ascii", 0, 5)).toBe(PDF_HEADER);
|
|
// Subject metadata is embedded in PDF info dict
|
|
const pdfString = buffer.toString("latin1");
|
|
expect(pdfString).toContain("/Subject");
|
|
});
|
|
});
|
|
|
|
describe("metadata rendering", () => {
|
|
it("should render user mentions with resolved display name", async () => {
|
|
const metadata: PDFExportMetadata = {
|
|
userMentions: [{ id: "user-123", display_name: "John Doe" }],
|
|
};
|
|
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [
|
|
{ type: "text", text: "Hello " },
|
|
{
|
|
type: "mention",
|
|
attrs: {
|
|
entity_name: "user_mention",
|
|
entity_identifier: "user-123",
|
|
},
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc, { metadata });
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("Hello");
|
|
expect(text).toContain("John Doe");
|
|
});
|
|
});
|
|
|
|
describe("complex documents", () => {
|
|
it("should render a full document with mixed content and verify all sections", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "heading",
|
|
attrs: { level: 1 },
|
|
content: [{ type: "text", text: "Project Overview" }],
|
|
},
|
|
{
|
|
type: "paragraph",
|
|
content: [
|
|
{ type: "text", text: "This document describes the " },
|
|
{ type: "text", text: "key features", marks: [{ type: "bold" }] },
|
|
{ type: "text", text: " of the project." },
|
|
],
|
|
},
|
|
{
|
|
type: "heading",
|
|
attrs: { level: 2 },
|
|
content: [{ type: "text", text: "Features" }],
|
|
},
|
|
{
|
|
type: "bulletList",
|
|
content: [
|
|
{
|
|
type: "listItem",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Feature A - Core functionality" }],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "listItem",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Feature B - Advanced options" }],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "heading",
|
|
attrs: { level: 2 },
|
|
content: [{ type: "text", text: "Code Example" }],
|
|
},
|
|
{
|
|
type: "codeBlock",
|
|
content: [{ type: "text", text: "function hello() {\n return 'world';\n}" }],
|
|
},
|
|
{
|
|
type: "blockquote",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Important: Review before deployment." }],
|
|
},
|
|
],
|
|
},
|
|
{ type: "horizontalRule" },
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "End of document." }],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc, {
|
|
title: "Project Overview",
|
|
author: "Development Team",
|
|
subject: "Technical Documentation",
|
|
});
|
|
|
|
const text = await extractPdfText(buffer);
|
|
|
|
// Verify metadata is embedded in PDF
|
|
const pdfString = buffer.toString("latin1");
|
|
expect(pdfString).toContain("/Title");
|
|
expect(pdfString).toContain("/Author");
|
|
expect(pdfString).toContain("/Subject");
|
|
|
|
// Verify all content sections are present
|
|
expect(text).toContain("Project Overview");
|
|
expect(text).toContain("This document describes the");
|
|
expect(text).toContain("key features");
|
|
expect(text).toContain("Features");
|
|
expect(text).toContain("Feature A - Core functionality");
|
|
expect(text).toContain("Feature B - Advanced options");
|
|
expect(text).toContain("Code Example");
|
|
expect(text).toContain("function hello");
|
|
expect(text).toContain("Important: Review before deployment");
|
|
expect(text).toContain("End of document");
|
|
});
|
|
|
|
it("should render deeply nested lists with all levels", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "bulletList",
|
|
content: [
|
|
{
|
|
type: "listItem",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Level 1" }],
|
|
},
|
|
{
|
|
type: "bulletList",
|
|
content: [
|
|
{
|
|
type: "listItem",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Level 2" }],
|
|
},
|
|
{
|
|
type: "bulletList",
|
|
content: [
|
|
{
|
|
type: "listItem",
|
|
content: [
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Level 3" }],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc);
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("Level 1");
|
|
expect(text).toContain("Level 2");
|
|
expect(text).toContain("Level 3");
|
|
});
|
|
});
|
|
|
|
describe("noAssets option", () => {
|
|
it("should render text but skip images when noAssets is true", async () => {
|
|
const doc: TipTapDocument = {
|
|
type: "doc",
|
|
content: [
|
|
{
|
|
type: "image",
|
|
attrs: { src: "https://example.com/image.png" },
|
|
},
|
|
{
|
|
type: "paragraph",
|
|
content: [{ type: "text", text: "Text after image" }],
|
|
},
|
|
],
|
|
};
|
|
|
|
const buffer = await renderPlaneDocToPdfBuffer(doc, { noAssets: true });
|
|
const text = await extractPdfText(buffer);
|
|
|
|
expect(text).toContain("Text after image");
|
|
});
|
|
});
|
|
});
|