typst-embedded-package 0.4.0

Support to embed typst package to the binary
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

#![cfg_attr(docsrs, feature(doc_auto_cfg))]

//! Embed typst packages directly in the binary.
//!
//! # How to use
//!
//! 1. Download package archives from <https://typst.app/universe/search/?kind=packages>
//! 1. Move those archives somewhere in the `src` directory
//! 1. Include the archives with [`include_package!`]
//! 1. Read the content of the archive with [`Package::read_archive`] (requires the `read-archive` feature)
//!
//! ```ignore
//! # use typst_embedded_package::{include_package, Package};
//! // Embed the package located at "/src/typst-packages/preview/cetz-0.3.1.tar.gz"
//! const CETZ: Package = include_package!("typst-packages" "preview" "cetz" (0, 3, 1));
//!
//! // Embed multiple packages.
//! const PACKAGES: [Package; 2] = include_package!(
//!     "typst-packages"
//!     [
//!         "preview" "cetz" (0, 3, 1),
//!         "preview" "oxifmt" (0, 2, 0),
//!     ]
//! );
//! ```

#[cfg(feature = "read-archive")]
mod archive;
#[cfg(feature = "read-archive")]
pub use archive::*;

use typst::diag::EcoString;
use typst::syntax::package::{PackageSpec, PackageVersion};

/// Information about an embedded package.
///
/// Created by the [`include_package!`] macro.
#[derive(Debug, Clone)]
pub struct Package {
    /// The namespace the package lives in.
    pub namespace: &'static str,
    /// The name of the package within its namespace.
    pub name: &'static str,
    /// The package's version.
    pub version: PackageVersion,
    /// The content of the package's tgz archive.
    pub archive: &'static [u8],
}

impl Package {
    /// Returns the [`PackageSpec`] of the package.
    pub fn spec(&self) -> PackageSpec {
        PackageSpec {
            namespace: EcoString::from(self.namespace),
            name: EcoString::from(self.name),
            version: self.version,
        }
    }
}

#[doc(hidden)]
pub mod __private {
    pub use typst::syntax::package::PackageVersion;
}

/// Embed one or more typst package as tgz archive.
///
/// This macro returns an [`Package`] or an array of [`Package`].
///
/// # Usage
///
/// Embed package archive located at `src/{root}/{namespace}/{name}-{X}.{Y}.{Z}.tar.gz`.
/// ```ignore
/// include_package!( {root} {namespace} {name} ({X}, {Y}, {Z}) );
/// include_package!(
///     {root}
///     [
///         {namespace} {name} ({X}, {Y}, {Z}),
///         {namespace} {name} ({X}, {Y}, {Z}),
///         ...
///     ]
/// );
/// ```
#[macro_export]
macro_rules! include_package {
    (
        $root:literal $namespace:literal $name:literal ($major:literal, $minor:literal, $patch:literal)
    ) => {
        $crate::Package {
            namespace: $namespace,
            name: $name,
            version: $crate::__private::PackageVersion {
                major: $major,
                minor: $minor,
                patch: $patch,
            },
            archive: include_bytes!(concat!(
                $root,
                "/",
                $namespace,
                "/",
                $name,
                "-",
                stringify!($major),
                ".",
                stringify!($minor),
                ".",
                stringify!($patch),
                ".tar.gz"
            )),
        }
    };

    (
        $root:literal
        [
            $( $namespace:literal $name:literal ($major:literal, $minor:literal, $patch:literal) ),* $(,)?
        ]
    ) => {
        [
            $(
                $crate::include_package!($root $namespace $name ($major, $minor, $patch) )
            ),*
        ]
    };

}