blitz-pdf 0.1.0 → 0.1.2

package/vendor/krilla/src/data.rs

@@ -0,0 +1,49 @@
+use std::fmt::{Debug, Formatter};
+use std::hash::{Hash, Hasher};
+use std::sync::Arc;
+
+/// A type that holds some bytes.
+#[derive(Clone)]
+pub struct Data(pub(crate) Arc<dyn AsRef<[u8]> + Send + Sync>);
+
+impl AsRef<[u8]> for Data {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref().as_ref()
+    }
+}
+
+impl Hash for Data {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.as_ref().hash(state);
+    }
+}
+
+impl From<Arc<dyn AsRef<[u8]> + Send + Sync>> for Data {
+    fn from(value: Arc<dyn AsRef<[u8]> + Send + Sync>) -> Self {
+        Self(value)
+    }
+}
+
+impl From<&'static [u8]> for Data {
+    fn from(value: &'static [u8]) -> Self {
+        Self(Arc::new(value))
+    }
+}
+
+impl From<Vec<u8>> for Data {
+    fn from(value: Vec<u8>) -> Self {
+        Self(Arc::new(value))
+    }
+}
+
+impl From<Arc<Vec<u8>>> for Data {
+    fn from(value: Arc<Vec<u8>>) -> Self {
+        Self(value)
+    }
+}
+
+impl Debug for Data {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Data {{..}}")
+    }
+}

package/vendor/krilla/src/document.rs

@@ -0,0 +1,156 @@
+//! Creating new PDF documents.
+//!
+//! When using krilla, the starting point is always the creation of a [`Document`]. A document
+//! represents _one_ PDF document, to which you can add pages or configure them in any
+//! other way you want.
+//!
+//! Unfortunately, creating PDFs always requires some kind of global state to keep track
+//! of different aspects in the creation process, meaning that it is not possible to
+//! generate multiple pages at the same time. Instead, you need to add pages separately
+//! by calling the [`Document::start_page`] method, which returns a new [`Page`] object that mutably
+//! borrows the global state from the document. Once the page is dropped, the global
+//! state is passed back to the original document, which you can then use to add even
+//! more pages.
+//!
+//! [`Page`]: Page
+
+use crate::chunk_container::ChunkContainer;
+use crate::destination::NamedDestination;
+use crate::error::KrillaResult;
+use crate::interchange::embed::EmbeddedFile;
+use crate::interchange::metadata::Metadata;
+use crate::interchange::outline::Outline;
+use crate::interchange::tagging::TagTree;
+use crate::page::{Page, PageSettings};
+#[cfg(feature = "pdf")]
+use crate::pdf::PdfDocument;
+use crate::serialize::{SerializeContext, SerializeSettings};
+use crate::surface::Location;
+
+/// A PDF document.
+pub struct Document {
+    pub(crate) serializer_context: SerializeContext,
+    pub(crate) chunk_container: ChunkContainer,
+}
+
+impl Default for Document {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Document {
+    /// Create a new document with default serialize settings.
+    pub fn new() -> Self {
+        let serializer_context = SerializeContext::new(SerializeSettings::default());
+        let chunk_container = ChunkContainer::new(&serializer_context);
+
+        Self {
+            serializer_context,
+            chunk_container,
+        }
+    }
+
+    /// Create a new document with custom serialize settings.
+    pub fn new_with(serialize_settings: SerializeSettings) -> Self {
+        let serializer_context = SerializeContext::new(serialize_settings);
+        let chunk_container = ChunkContainer::new(&serializer_context);
+
+        Self {
+            serializer_context,
+            chunk_container,
+        }
+    }
+
+    /// Start a new page with default settings.
+    pub fn start_page(&mut self) -> Page<'_> {
+        let page_index = self.serializer_context.page_infos().iter().len();
+        Page::new(
+            &mut self.serializer_context,
+            &mut self.chunk_container,
+            page_index,
+            PageSettings::default(),
+        )
+    }
+
+    /// Start a new page with specific page settings.
+    pub fn start_page_with(&mut self, page_settings: PageSettings) -> Page<'_> {
+        let page_index = self.serializer_context.page_infos().iter().len();
+        Page::new(
+            &mut self.serializer_context,
+            &mut self.chunk_container,
+            page_index,
+            page_settings,
+        )
+    }
+
+    /// Embed the pages (0-indexed) from the given
+    /// PDF document.
+    #[cfg(feature = "pdf")]
+    pub fn embed_pdf_pages(&mut self, pdf: &PdfDocument, page_indices: &[usize]) {
+        self.serializer_context.embed_pdf_pages(pdf, page_indices);
+    }
+
+    /// Set the location that should be assumed for subsequent operations.
+    pub fn set_location(&mut self, location: Location) {
+        self.serializer_context.set_location(location);
+    }
+
+    /// Reset the location that should be assumed for subsequent operations.
+    pub fn reset_location(&mut self) {
+        self.serializer_context.reset_location();
+    }
+
+    /// Set the outline of the document.
+    pub fn set_outline(&mut self, outline: Outline) {
+        self.serializer_context.set_outline(outline);
+    }
+
+    /// Set the metadata of the document.
+    pub fn set_metadata(&mut self, metadata: Metadata) {
+        self.chunk_container.metadata = Some(metadata);
+    }
+
+    /// Set the tag tree of the document.
+    pub fn set_tag_tree(&mut self, tag_tree: TagTree) {
+        self.serializer_context.set_tag_tree(tag_tree);
+    }
+
+    /// Embed a new file in the PDF document.
+    ///
+    /// Returns `None` if the file couldn't be embedded because a file
+    /// with the same name has already been embedded.
+    pub fn embed_file(&mut self, file: EmbeddedFile) -> Option<()> {
+        self.serializer_context
+            .embed_file(&mut self.chunk_container, file)
+    }
+
+    /// Manually register a global named destination.
+    ///
+    /// Named destinations used in link annotations are automatically registered, so you don't need
+    /// to call this function for them.
+    ///
+    /// Returns `None` if a named destination with the same name and a different destination has
+    /// already been registered, and therefore could not be registered again.
+    #[must_use]
+    pub fn register_named_destination(&mut self, dest: NamedDestination) -> Option<()> {
+        self.serializer_context
+            .register_named_destination(dest)
+            .map(|_| ())
+    }
+
+    /// Attempt to export the document to a PDF file.
+    pub fn finish(mut self) -> KrillaResult<Vec<u8>> {
+        // Write empty page if none has been created yet.
+        if self.serializer_context.page_infos().is_empty() {
+            self.start_page();
+        }
+
+        let Self {
+            serializer_context,
+            chunk_container,
+        } = self;
+
+        Ok(serializer_context.finish(chunk_container)?.finish())
+    }
+}

package/vendor/krilla/src/error.rs

@@ -0,0 +1,170 @@
+//! Error handling.
+//!
+//! There are a lot of things that can go wrong when writing a PDF, like for example when
+//! invalid fonts are provided. This module provides the basic error types krilla uses.
+
+use std::error::Error;
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use crate::configure::{ValidationError, Validators};
+#[cfg(feature = "raster-images")]
+use crate::graphics::image::Image;
+#[cfg(feature = "pdf")]
+use crate::pdf::{PdfDocument, PdfError};
+use crate::surface::Location;
+use crate::tagging::TagId;
+use crate::text::Font;
+
+/// A wrapper type for krilla errors.
+pub type KrillaResult<T> = Result<T, KrillaError>;
+
+/// An error in krilla.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum KrillaError {
+    /// An error while attempting to embed a font.
+    Font(Font, String),
+    /// A list of validation errors. Can only occur if you set the `validator` in
+    /// the [`SerializeSettings`] to something else than the dummy validator.
+    ///
+    /// [`SerializeSettings`]: crate::SerializeSettings
+    Validation(Vec<(ValidationError, Validators)>),
+    /// A hard limit of the selected PDF version was exceeded.
+    Limit(LimitError),
+    /// The same destination name has been associated with two different destinations,
+    /// which is prohibited.
+    DuplicateNamedDestination(Arc<String>),
+    /// A duplicate [`Tag::id`] was provided.
+    ///
+    /// [`Tag::id`]: crate::interchange::tagging::Tag::id
+    DuplicateTagId(TagId, Option<Location>),
+    /// A [`TagId`] was not found in the [`TagTree`].
+    ///
+    /// [`TagTree`]: crate::interchange::tagging::TagTree
+    UnknownTagId(TagId, Option<Location>),
+    /// An image couldn't be processed properly.
+    ///
+    /// The third argument contains the error message.
+    #[cfg(feature = "raster-images")]
+    Image(Image, Option<Location>, String),
+    /// An embedded PDF document couldn't be processed properly.
+    #[cfg(feature = "pdf")]
+    Pdf(PdfDocument, PdfError, Option<Location>),
+    /// A sixteen bit image was used, even though it isn't
+    /// supported by the used PDF version (only available in PDF 1.5+).
+    #[cfg(feature = "raster-images")]
+    SixteenBitImage(Image, Option<Location>),
+}
+
+impl Display for KrillaError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            KrillaError::Font(_, message) => write!(f, "failed to embed font: {message}"),
+            KrillaError::Validation(errors) => {
+                let count = errors.len();
+                write!(
+                    f,
+                    "validation failed with {count} {}",
+                    if count == 1 { "error" } else { "errors" }
+                )
+            }
+            KrillaError::Limit(error) => write!(f, "PDF version limit exceeded: {error}"),
+            KrillaError::DuplicateNamedDestination(name) => {
+                write!(f, "duplicate named destination: {name}")
+            }
+            KrillaError::DuplicateTagId(id, location) => {
+                write!(f, "duplicate tag id {id:?}")?;
+                write_location(f, *location)
+            }
+            KrillaError::UnknownTagId(id, location) => {
+                write!(f, "unknown tag id {id:?}")?;
+                write_location(f, *location)
+            }
+            #[cfg(feature = "raster-images")]
+            KrillaError::Image(_, location, message) => {
+                write!(f, "failed to process image")?;
+                write_location(f, *location)?;
+                write!(f, ": {message}")
+            }
+            #[cfg(feature = "pdf")]
+            KrillaError::Pdf(_, error, location) => {
+                write!(f, "failed to process embedded PDF")?;
+                write_location(f, *location)?;
+                write!(f, ": {error}")
+            }
+            #[cfg(feature = "raster-images")]
+            KrillaError::SixteenBitImage(_, location) => {
+                write!(
+                    f,
+                    "sixteen bit images require PDF 1.5 or newer, but the selected PDF version does not support them"
+                )?;
+                write_location(f, *location)
+            }
+        }
+    }
+}
+
+impl Error for KrillaError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            KrillaError::Limit(error) => Some(error),
+            #[cfg(feature = "pdf")]
+            KrillaError::Pdf(_, error, _) => Some(error),
+            _ => None,
+        }
+    }
+}
+
+/// A limit imposed by the selected PDF version.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum LimitError {
+    /// A float exceeded the maximum allowed size for the PDF version.
+    TooLargeFloat,
+    /// An array exceeded the maximum allowed length for the PDF version.
+    TooLongArray,
+    /// A dictionary exceeded the maximum allowed number of entries for the PDF version.
+    TooLongDictionary,
+}
+
+impl Display for LimitError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            LimitError::TooLargeFloat => write!(f, "a float exceeded the maximum allowed size"),
+            LimitError::TooLongArray => write!(f, "an array exceeded the maximum allowed length"),
+            LimitError::TooLongDictionary => {
+                write!(
+                    f,
+                    "a dictionary exceeded the maximum allowed number of entries"
+                )
+            }
+        }
+    }
+}
+
+impl Error for LimitError {}
+
+fn write_location(f: &mut Formatter<'_>, location: Option<Location>) -> fmt::Result {
+    if let Some(location) = location {
+        write!(f, " at location {location}")
+    } else {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::error::Error as _;
+
+    use super::{KrillaError, LimitError};
+
+    #[test]
+    fn krilla_error_implements_error() {
+        let error = KrillaError::Limit(LimitError::TooLongArray);
+
+        assert_eq!(
+            error.to_string(),
+            "PDF version limit exceeded: an array exceeded the maximum allowed length"
+        );
+        assert!(error.source().is_some());
+    }
+}