@a3s-lab/office 0.31.0 → 0.33.0

package/dist/0~markdown-editor.js

@@ -11,8 +11,8 @@ import { Markdown } from "@tiptap/markdown";
 import starter_kit from "@tiptap/starter-kit";
 import { Bold, Code2, Columns2, Image, Italic, Link2, List, ListChecks, ListOrdered, Minus, PencilLine, Quote, Redo2, Strikethrough, Table2, Undo2, Unlink } from "lucide-react";
 import { mergeOfficeTiptapExtensions, documentPlainTextAsHtml, customSelectionMenuItems } from "./0~5050.js";
-import { OfficeSelect, isWorkspaceContextMenuKeyboardEvent, WorkOfficeZoomControls, WorkOfficeStatusBar, Dialog, WorkOfficeRibbon, workspaceContextMenuPosition, WorkspaceContextMenu, WorkOfficeRibbonGroup, WorkOfficeRibbonButton, WorkOfficePreviewBar } from "./0~4595.js";
-import { button_Button, OfficeTiptapPresenceLayer, useOfficePublishPresenceLocation, stepOfficeZoom, office_text_field_OfficeTextField, useOfficeEditorWheelZoom, MarkdownSourcePresenceLayer } from "./0~6090.js";
+import { OfficeSelect, isWorkspaceContextMenuKeyboardEvent, WorkOfficeZoomControls, WorkOfficeStatusBar, WorkOfficeRibbon, workspaceContextMenuPosition, WorkspaceContextMenu, WorkOfficeRibbonGroup, WorkOfficeRibbonButton, WorkOfficePreviewBar } from "./0~9073.js";
+import { stepOfficeZoom, MarkdownSourcePresenceLayer, button_Button, OfficeTiptapPresenceLayer, useOfficePublishPresenceLocation, Dialog, office_text_field_OfficeTextField, useOfficeEditorWheelZoom } from "./0~8136.js";
 import { normalizeDocumentHref, DOCUMENT_LINK_VALIDATION_MESSAGE } from "./0~work-document-links.js";
 import { readOfficeMarkdownCollaboration as readWorkOfficeMarkdownCollaboration, createOfficeMarkdownCollaborationBinding as createWorkOfficeMarkdownCollaborationBinding } from "./2591.js";
 import { useOfficeEditorInitialFocus, useOfficeCollaborationLocationNavigator, WorkEditorLoadingState } from "./432.js";

package/dist/0~pdf-page-organization-engine.js

@@ -0,0 +1,187 @@
+import { PDFDocument, PDFName, degrees } from "pdf-lib";
+import { validatedPdfPageSize, PdfPageOrganizationError, PDF_PAGE_ORGANIZATION_MAX_SOURCE_BYTES, validatedPdfInsertionIndex, validatedPdfSplitBoundaries, PDF_PAGE_ORGANIZATION_MAX_IMPORT_BYTES, validatedPdfPageOrder, validatedPdfPageIndexes } from "./0~pdf-viewer.js";
+const RISKY_STRUCTURE_KEYS = [
+    'AcroForm',
+    'Outlines',
+    'StructTreeRoot'
+];
+const COPY_DIAGNOSTIC = {
+    code: 'pdf.pages.catalog-not-copied',
+    message: "Page-only exports do not copy document-level outlines, forms, tags, attachments, scripts, or signatures."
+};
+async function applyPdfPageOrganizationJob(job) {
+    const source = await loadBoundedPdf(job.source, PDF_PAGE_ORGANIZATION_MAX_SOURCE_BYTES, 'source');
+    assertPageCount(source.getPageCount());
+    if ('export' === job.kind) return exportPages(source, job.operation);
+    assertUnsigned(source);
+    return mutatePages(source, job.mutation, job.importSource);
+}
+async function mutatePages(source, mutation, importSource) {
+    const pageCount = source.getPageCount();
+    if ('rotate' === mutation.kind) {
+        const indexes = validatedPdfPageIndexes(mutation.pageIndexes, pageCount);
+        for (const pageIndex of indexes){
+            const page = source.getPage(pageIndex);
+            const current = page.getRotation().angle;
+            if (!Number.isSafeInteger(current) || current % 90 !== 0) throw new PdfPageOrganizationError('pdf.pages.unsupported-rotation', `Page ${pageIndex + 1} has unsupported rotation ${String(current)}.`);
+            page.setRotation(degrees(normalizeDegrees(current + mutation.degrees)));
+        }
+        return mutationResult(source);
+    }
+    if ('insert-blank' === mutation.kind) {
+        const index = validatedPdfInsertionIndex(mutation.index, pageCount);
+        const size = validatedPdfPageSize(mutation.size);
+        assertPageCount(pageCount + 1);
+        source.insertPage(index, [
+            size.width,
+            size.height
+        ]);
+        return mutationResult(source);
+    }
+    if ('delete' === mutation.kind) {
+        assertNoRiskyStructure(source);
+        const indexes = validatedPdfPageIndexes(mutation.pageIndexes, pageCount);
+        if (indexes.length >= pageCount) throw new PdfPageOrganizationError('pdf.pages.empty-document', 'A PDF must retain at least one page.');
+        for (const pageIndex of [
+            ...indexes
+        ].sort((left, right)=>right - left))source.removePage(pageIndex);
+        return mutationResult(source);
+    }
+    if ('reorder' === mutation.kind) {
+        assertNoRiskyStructure(source);
+        const pageOrder = validatedPdfPageOrder(mutation.pageOrder, pageCount);
+        const reordered = await PDFDocument.create({
+            updateMetadata: false
+        });
+        copyMetadata(source, reordered);
+        const pages = await reordered.copyPages(source, pageOrder);
+        for (const page of pages)reordered.addPage(page);
+        return mutationResult(reordered);
+    }
+    const index = validatedPdfInsertionIndex(mutation.index, pageCount);
+    if (!importSource) throw new PdfPageOrganizationError('pdf.pages.missing-import', 'Choose a PDF to merge before applying this operation.');
+    assertNoRiskyStructure(source);
+    const imported = await loadBoundedPdf(importSource, PDF_PAGE_ORGANIZATION_MAX_IMPORT_BYTES, 'import');
+    assertSafeImport(imported);
+    assertPageCount(pageCount + imported.getPageCount());
+    const copied = await source.copyPages(imported, imported.getPageIndices());
+    for(let offset = 0; offset < copied.length; offset += 1){
+        const page = copied[offset];
+        if (page) source.insertPage(index + offset, page);
+    }
+    return mutationResult(source);
+}
+async function exportPages(source, operation) {
+    const pageCount = source.getPageCount();
+    if ('extract' === operation.kind) {
+        const indexes = validatedPdfPageIndexes(operation.pageIndexes, pageCount, {
+            preserveOrder: true
+        });
+        return {
+            diagnostics: sourceHasRiskyStructure(source) ? [
+                COPY_DIAGNOSTIC
+            ] : [],
+            files: [
+                await copyPageRange(source, indexes)
+            ],
+            kind: 'exported'
+        };
+    }
+    const boundaries = validatedPdfSplitBoundaries(operation.splitAfterPageIndexes, pageCount);
+    const ranges = [];
+    let start = 0;
+    for (const boundary of boundaries){
+        ranges.push(range(start, boundary + 1));
+        start = boundary + 1;
+    }
+    ranges.push(range(start, pageCount));
+    return {
+        diagnostics: sourceHasRiskyStructure(source) ? [
+            COPY_DIAGNOSTIC
+        ] : [],
+        files: await Promise.all(ranges.map((indexes)=>copyPageRange(source, indexes))),
+        kind: 'exported'
+    };
+}
+async function copyPageRange(source, indexes) {
+    const output = await PDFDocument.create({
+        updateMetadata: false
+    });
+    copyMetadata(source, output);
+    const pages = await output.copyPages(source, indexes);
+    for (const page of pages)output.addPage(page);
+    return {
+        pageCount: indexes.length,
+        source: await output.save()
+    };
+}
+async function mutationResult(source) {
+    return {
+        diagnostics: [],
+        kind: 'mutated',
+        pageCount: source.getPageCount(),
+        source: await source.save()
+    };
+}
+async function loadBoundedPdf(source, byteLimit, label) {
+    const byteLength = source.byteLength;
+    if (byteLength < 5 || byteLength > byteLimit) throw new PdfPageOrganizationError('pdf.pages.source-limit', `The PDF ${label} must be between 5 bytes and ${byteLimit} bytes.`);
+    try {
+        const pdf = await PDFDocument.load(source, {
+            ignoreEncryption: false,
+            throwOnInvalidObject: true,
+            updateMetadata: false
+        });
+        if (pdf.isEncrypted) throw new PdfPageOrganizationError('pdf.pages.encrypted-source', `The encrypted PDF ${label} cannot be reorganized without an authenticated decryption provider.`);
+        return pdf;
+    } catch (error) {
+        if (error instanceof PdfPageOrganizationError) throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        if (/encrypt/i.test(message)) throw new PdfPageOrganizationError('pdf.pages.encrypted-source', `The encrypted PDF ${label} cannot be reorganized without an authenticated decryption provider.`);
+        throw new PdfPageOrganizationError('pdf.pages.invalid-source', `The PDF ${label} is malformed or unsupported: ${message.slice(0, 240)}`);
+    }
+}
+function assertPageCount(pageCount) {
+    if (!Number.isSafeInteger(pageCount) || pageCount < 1 || pageCount > 4096) throw new PdfPageOrganizationError('pdf.pages.page-limit', "PDF page organization supports 1 to 4096 pages per result.");
+}
+function assertUnsigned(source) {
+    if (source.catalog.has(PDFName.of('Perms'))) throw new PdfPageOrganizationError('pdf.pages.signed-source', 'This PDF declares a signature permission dictionary. Rewriting it would invalidate its trust evidence.');
+}
+function assertNoRiskyStructure(source) {
+    if (!sourceHasRiskyStructure(source)) return;
+    throw new PdfPageOrganizationError('pdf.pages.risky-structure', 'Delete, reorder, and merge are disabled for PDFs with forms, outlines, or tagged structure because page references cannot be rewritten safely.');
+}
+function assertSafeImport(source) {
+    if (!sourceHasRiskyStructure(source) && !source.catalog.has(PDFName.of('Perms'))) return;
+    throw new PdfPageOrganizationError('pdf.pages.risky-import', 'The PDF selected for merge contains forms, outlines, tags, or signature permissions that cannot be copied safely.');
+}
+function sourceHasRiskyStructure(source) {
+    return RISKY_STRUCTURE_KEYS.some((key)=>source.catalog.has(PDFName.of(key)));
+}
+function copyMetadata(source, target) {
+    setIfDefined(source.getTitle(), (value)=>target.setTitle(value));
+    setIfDefined(source.getAuthor(), (value)=>target.setAuthor(value));
+    setIfDefined(source.getSubject(), (value)=>target.setSubject(value));
+    setIfDefined(source.getCreator(), (value)=>target.setCreator(value));
+    setIfDefined(source.getProducer(), (value)=>target.setProducer(value));
+    setIfDefined(source.getCreationDate(), (value)=>target.setCreationDate(value));
+    setIfDefined(source.getModificationDate(), (value)=>target.setModificationDate(value));
+    const keywords = source.getKeywords();
+    if (keywords) target.setKeywords([
+        keywords
+    ]);
+}
+function setIfDefined(value, setter) {
+    if (void 0 !== value) setter(value);
+}
+function normalizeDegrees(value) {
+    const normalized = (value % 360 + 360) % 360;
+    if (0 === normalized || 90 === normalized || 180 === normalized || 270 === normalized) return normalized;
+    throw new PdfPageOrganizationError('pdf.pages.unsupported-rotation', `PDF page rotation ${value} is not a multiple of 90 degrees.`);
+}
+function range(start, end) {
+    return Array.from({
+        length: Math.max(0, end - start)
+    }, (_, index)=>start + index);
+}
+export { applyPdfPageOrganizationJob };