typst 0.13.3-x86_64-linux-musl

data/ext/typst/src/world.rs

@@ -0,0 +1,351 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::{Mutex, OnceLock};
+
+use chrono::{DateTime, Datelike, Local};
+use ecow::eco_format;
+use typst::diag::{FileError, FileResult, StrResult};
+use typst::foundations::{Bytes, Datetime, Dict};
+use typst::syntax::{FileId, Source, VirtualPath};
+use typst::text::{Font, FontBook};
+use typst::utils::LazyHash;
+use typst::{Features, Library, LibraryBuilder, World};
+use typst_kit::{
+    fonts::{FontSearcher, FontSlot},
+    package::PackageStorage,
+};
+
+use std::collections::HashMap;
+
+use crate::download::SlientDownload;
+
+/// A world that provides access to the operating system.
+pub struct SystemWorld {
+    /// The working directory.
+    workdir: Option<PathBuf>,
+    /// The canonical path to the input file.
+    input: PathBuf,
+    /// The root relative to which absolute paths are resolved.
+    root: PathBuf,
+    /// The input path.
+    main: FileId,
+    /// Typst's standard library.
+    library: LazyHash<Library>,
+    /// Metadata about discovered fonts.
+    book: LazyHash<FontBook>,
+    /// Locations of and storage for lazily loaded fonts.
+    fonts: Vec<FontSlot>,
+    /// Maps file ids to source files and buffers.
+    slots: Mutex<HashMap<FileId, FileSlot>>,
+    /// Holds information about where packages are stored.
+    package_storage: PackageStorage,
+    /// The current datetime if requested. This is stored here to ensure it is
+    /// always the same within one compilation. Reset between compilations.
+    now: OnceLock<DateTime<Local>>,
+}
+
+impl World for SystemWorld {
+    fn library(&self) -> &LazyHash<Library> {
+        &self.library
+    }
+
+    fn book(&self) -> &LazyHash<FontBook> {
+        &self.book
+    }
+
+    fn main(&self) -> FileId {
+        self.main
+    }
+
+    fn source(&self, id: FileId) -> FileResult<Source> {
+        self.slot(id, |slot| slot.source(&self.root, &self.package_storage))
+    }
+
+    fn file(&self, id: FileId) -> FileResult<Bytes> {
+        self.slot(id, |slot| slot.file(&self.root, &self.package_storage))
+    }
+
+    fn font(&self, index: usize) -> Option<Font> {
+        self.fonts[index].get()
+    }
+
+    fn today(&self, offset: Option<i64>) -> Option<Datetime> {
+        let now = self.now.get_or_init(chrono::Local::now);
+
+        let naive = match offset {
+            None => now.naive_local(),
+            Some(o) => now.naive_utc() + chrono::Duration::hours(o),
+        };
+
+        Datetime::from_ymd(
+            naive.year(),
+            naive.month().try_into().ok()?,
+            naive.day().try_into().ok()?,
+        )
+    }
+}
+
+impl SystemWorld {
+    pub fn builder(root: PathBuf, main: PathBuf) -> SystemWorldBuilder {
+        SystemWorldBuilder::new(root, main)
+    }
+
+    /// Access the canonical slot for the given file id.
+    fn slot<F, T>(&self, id: FileId, f: F) -> T
+    where
+        F: FnOnce(&mut FileSlot) -> T,
+    {
+        let mut map = self.slots.lock().unwrap();
+        f(map.entry(id).or_insert_with(|| FileSlot::new(id)))
+    }
+
+    /// The id of the main source file.
+    pub fn main(&self) -> FileId {
+        self.main
+    }
+
+    /// The root relative to which absolute paths are resolved.
+    pub fn root(&self) -> &Path {
+        &self.root
+    }
+
+    /// The current working directory.
+    pub fn workdir(&self) -> &Path {
+        self.workdir.as_deref().unwrap_or(Path::new("."))
+    }
+
+    /// Reset the compilation state in preparation of a new compilation.
+    pub fn reset(&mut self) {
+        for slot in self.slots.lock().unwrap().values_mut() {
+            slot.reset();
+        }
+        self.now.take();
+    }
+
+    /// Return the canonical path to the input file.
+    pub fn input(&self) -> &PathBuf {
+        &self.input
+    }
+
+    /// Lookup a source file by id.
+    #[track_caller]
+    pub fn lookup(&self, id: FileId) -> Source {
+        self.source(id)
+            .expect("file id does not point to any source file")
+    }
+}
+
+pub struct SystemWorldBuilder {
+    root: PathBuf,
+    main: PathBuf,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    inputs: Dict,
+    features: Features,
+}
+
+impl SystemWorldBuilder {
+    pub fn new(root: PathBuf, main: PathBuf) -> Self {
+        Self {
+            root,
+            main,
+            font_paths: Vec::new(),
+            ignore_system_fonts: false,
+            inputs: Dict::default(),
+            features: Features::default(),
+        }
+    }
+
+    pub fn font_paths(mut self, font_paths: Vec<PathBuf>) -> Self {
+        self.font_paths = font_paths;
+        self
+    }
+
+    pub fn ignore_system_fonts(mut self, ignore: bool) -> Self {
+        self.ignore_system_fonts = ignore;
+        self
+    }
+
+    pub fn inputs(mut self, inputs: Dict) -> Self {
+        self.inputs = inputs;
+        self
+    }
+
+    pub fn features(mut self, features: Features) -> Self {
+        self.features = features;
+        self
+    }
+
+    pub fn build(self) -> StrResult<SystemWorld> {
+        let fonts = FontSearcher::new()
+            .include_system_fonts(!self.ignore_system_fonts)
+            .search_with(&self.font_paths);
+
+        let input = self.main.canonicalize().map_err(|_| {
+            eco_format!("input file not found (searched at {})", self.main.display())
+        })?;
+        // Resolve the virtual path of the main file within the project root.
+        let main_path = VirtualPath::within_root(&self.main, &self.root)
+            .ok_or("input file must be contained in project root")?;
+
+        let world = SystemWorld {
+            workdir: std::env::current_dir().ok(),
+            input,
+            root: self.root,
+            main: FileId::new(None, main_path),
+            library: LazyHash::new(LibraryBuilder::default().with_inputs(self.inputs).with_features(self.features).build()),
+            book: LazyHash::new(fonts.book),
+            fonts: fonts.fonts,
+            slots: Mutex::default(),
+            package_storage: PackageStorage::new(None, None, crate::download::downloader()),
+            now: OnceLock::new(),
+        };
+        Ok(world)
+    }
+}
+
+/// Holds canonical data for all paths pointing to the same entity.
+///
+/// Both fields can be populated if the file is both imported and read().
+struct FileSlot {
+    /// The slot's canonical file id.
+    id: FileId,
+    /// The lazily loaded and incrementally updated source file.
+    source: SlotCell<Source>,
+    /// The lazily loaded raw byte buffer.
+    file: SlotCell<Bytes>,
+}
+
+impl FileSlot {
+    /// Create a new path slot.
+    fn new(id: FileId) -> Self {
+        Self {
+            id,
+            file: SlotCell::new(),
+            source: SlotCell::new(),
+        }
+    }
+
+    /// Marks the file as not yet accessed in preparation of the next
+    /// compilation.
+    fn reset(&mut self) {
+        self.source.reset();
+        self.file.reset();
+    }
+
+    fn source(&mut self, root: &Path, package_storage: &PackageStorage) -> FileResult<Source> {
+        let id = self.id;
+        self.source.get_or_init(
+            || system_path(root, id, package_storage),
+            |data, prev| {
+                let text = decode_utf8(&data)?;
+                if let Some(mut prev) = prev {
+                    prev.replace(text);
+                    Ok(prev)
+                } else {
+                    Ok(Source::new(self.id, text.into()))
+                }
+            },
+        )
+    }
+
+    fn file(&mut self, root: &Path, package_storage: &PackageStorage) -> FileResult<Bytes> {
+        let id = self.id;
+        self.file.get_or_init(
+            || system_path(root, id, package_storage),
+            |data, _| Ok(Bytes::new(data)),
+        )
+    }
+}
+
+/// The path of the slot on the system.
+fn system_path(root: &Path, id: FileId, package_storage: &PackageStorage) -> FileResult<PathBuf> {
+    // Determine the root path relative to which the file path
+    // will be resolved.
+    let buf;
+    let mut root = root;
+    if let Some(spec) = id.package() {
+        buf = package_storage.prepare_package(spec, &mut SlientDownload(&spec))?;
+        root = &buf;
+    }
+
+    // Join the path to the root. If it tries to escape, deny
+    // access. Note: It can still escape via symlinks.
+    id.vpath().resolve(root).ok_or(FileError::AccessDenied)
+}
+
+/// Lazily processes data for a file.
+struct SlotCell<T> {
+    /// The processed data.
+    data: Option<FileResult<T>>,
+    /// A hash of the raw file contents / access error.
+    fingerprint: u128,
+    /// Whether the slot has been accessed in the current compilation.
+    accessed: bool,
+}
+
+impl<T: Clone> SlotCell<T> {
+    /// Creates a new, empty cell.
+    fn new() -> Self {
+        Self {
+            data: None,
+            fingerprint: 0,
+            accessed: false,
+        }
+    }
+
+    /// Marks the cell as not yet accessed in preparation of the next
+    /// compilation.
+    fn reset(&mut self) {
+        self.accessed = false;
+    }
+
+    /// Gets the contents of the cell or initialize them.
+    fn get_or_init(
+        &mut self,
+        path: impl FnOnce() -> FileResult<PathBuf>,
+        f: impl FnOnce(Vec<u8>, Option<T>) -> FileResult<T>,
+    ) -> FileResult<T> {
+        // If we accessed the file already in this compilation, retrieve it.
+        if std::mem::replace(&mut self.accessed, true) {
+            if let Some(data) = &self.data {
+                return data.clone();
+            }
+        }
+
+        // Read and hash the file.
+        let result = path().and_then(|p| read(&p));
+        let fingerprint = typst::utils::hash128(&result);
+
+        // If the file contents didn't change, yield the old processed data.
+        if std::mem::replace(&mut self.fingerprint, fingerprint) == fingerprint {
+            if let Some(data) = &self.data {
+                return data.clone();
+            }
+        }
+
+        let prev = self.data.take().and_then(Result::ok);
+        let value = result.and_then(|data| f(data, prev));
+        self.data = Some(value.clone());
+
+        value
+    }
+}
+
+/// Read a file.
+fn read(path: &Path) -> FileResult<Vec<u8>> {
+    let f = |e| FileError::from_io(e, path);
+    if fs::metadata(path).map_err(f)?.is_dir() {
+        Err(FileError::IsDirectory)
+    } else {
+        fs::read(path).map_err(f)
+    }
+}
+
+/// Decode UTF-8 with an optional BOM.
+fn decode_utf8(buf: &[u8]) -> FileResult<&str> {
+    // Remove UTF-8 BOM.
+    Ok(std::str::from_utf8(
+        buf.strip_prefix(b"\xef\xbb\xbf").unwrap_or(buf),
+    )?)
+}

data/lib/base.rb

@@ -0,0 +1,169 @@
+module Typst
+  class Base
+    attr_accessor :options
+    attr_accessor :compiled
+
+    def initialize(*options)
+      if options.size.zero?
+        raise "No options given"
+      elsif options.first.is_a?(String)
+        file, options = options
+        options ||= {}
+        options[:file] = file
+      elsif options.first.is_a?(Hash)
+        options = options.first
+      end
+
+      if options.has_key?(:file)
+        raise "Can't find file" unless File.exist?(options[:file])
+      elsif options.has_key?(:body)
+        raise "Empty body" if options[:body].to_s.empty?
+      elsif options.has_key?(:zip)
+        raise "Can't find zip" unless File.exist?(options[:zip])
+      else
+        raise "No input given"
+      end
+
+      root = Pathname.new(options[:root] || ".").expand_path
+      raise "Invalid path for root" unless root.exist?
+      options[:root] = root.to_s
+
+      font_paths = (options[:font_paths] || []).collect{ |fp| Pathname.new(fp).expand_path }
+      options[:font_paths] = font_paths.collect(&:to_s)
+
+      options[:dependencies] ||= {}
+      options[:fonts] ||= {}
+      options[:sys_inputs] ||= {}
+    
+      self.options = options
+    end
+
+    def typst_args
+      [options[:file], options[:root], options[:font_paths], File.dirname(__FILE__), false, options[:sys_inputs].map{ |k,v| [k.to_s,v.to_s] }.to_h]
+    end
+
+    def self.from_s(main_source, **options)
+      dependencies = options[:dependencies] ||= {}
+      fonts = options[:fonts] ||= {}
+
+      Dir.mktmpdir do |tmp_dir|
+        tmp_main_file = Pathname.new(tmp_dir).join("main.typ")
+        File.write(tmp_main_file, main_source)
+
+        dependencies.each do |dep_name, dep_source|
+          tmp_dep_file = Pathname.new(tmp_dir).join(dep_name)
+          File.write(tmp_dep_file, dep_source)
+        end
+
+        relative_font_path = Pathname.new(tmp_dir).join("fonts")
+        fonts.each do |font_name, font_bytes|
+          Pathname.new(relative_font_path).mkpath
+          tmp_font_file = relative_font_path.join(font_name)
+          File.write(tmp_font_file, font_bytes)
+        end
+
+        options[:file] = tmp_main_file
+        options[:root] = tmp_dir
+        options[:font_paths] = [relative_font_path]
+
+        if options[:format]
+          Typst::formats[options[:format]].new(**options)
+        else
+          new(**options)
+        end
+      end
+    end
+
+    def self.from_zip(zip_file_path, main_file = nil, **options)
+      options[:dependencies] ||= {}
+      options[:fonts] ||= {}
+
+      Zip::File.open(zip_file_path) do |zipfile|
+        file_names = zipfile.dir.glob("*").collect{ |f| f.name }
+        case
+          when file_names.include?(main_file) then tmp_main_file = main_file
+          when file_names.include?("main.typ") then tmp_main_file = "main.typ"
+          when file_names.size == 1 then tmp_main_file = file_names.first
+          else raise "no main file found"
+        end
+        main_source = zipfile.file.read(tmp_main_file)
+        file_names.delete(tmp_main_file)
+        file_names.delete("fonts/")
+
+        file_names.each do |dep_name|
+          options[:dependencies][dep_name] = zipfile.file.read(dep_name)
+        end
+
+        font_file_names = zipfile.dir.glob("fonts/*").collect{ |f| f.name }
+        font_file_names.each do |font_name|
+          options[:fonts][Pathname.new(font_name).basename.to_s] = zipfile.file.read(font_name)
+        end
+
+        options[:main_file] = tmp_main_file
+
+        from_s(main_source, **options)
+      end
+    end
+
+    def with_dependencies(dependencies)
+      self.options[:dependencies] = self.options[:dependencies].merge(dependencies)
+      self
+    end
+
+    def with_fonts(fonts)
+      self.options[:fonts] = self.options[:fonts].merge(fonts)
+      self
+    end
+
+    def with_inputs(inputs)
+      self.options[:sys_inputs] = self.options[:sys_inputs].merge(inputs)
+      self
+    end
+
+    def with_font_paths(font_paths)
+      self.options[:font_paths] = self.options[:font_paths] + font_paths
+      self
+    end
+
+    def with_root(root)
+      self.options[:root] = root
+      self
+    end
+
+    def compile(format, **options)
+      raise "Invalid format" if Typst::formats[format].nil?
+
+      options = self.options.merge(options)
+
+      if options.has_key?(:file)
+        Typst::formats[format].new(**options).compiled
+      elsif options.has_key?(:body)
+        Typst::formats[format].from_s(options[:body], **options).compiled
+      elsif options.has_key?(:zip)
+        Typst::formats[format].from_zip(options[:zip], options[:main_file], **options).compiled
+      else
+        raise "No input given"
+      end
+    end
+
+    def write(output)
+      STDERR.puts "DEPRECATION WARNING: this method will go away in a future version"
+      compiled.write(output)
+    end
+
+    def document
+      STDERR.puts "DEPRECATION WARNING: this method will go away in a future version"
+      compiled.document
+    end
+
+    def bytes
+      STDERR.puts "DEPRECATION WARNING: this method will go away in a future version"
+      compiled.bytes
+    end
+
+    def pages
+      STDERR.puts "DEPRECATION WARNING: this method will go away in a future version"
+      compiled.pages
+    end
+  end
+end

data/lib/document.rb

@@ -0,0 +1,29 @@
+module Typst
+  class Document
+    attr_accessor :bytes
+
+    def initialize(bytes)
+      @bytes = bytes
+    end
+
+    def write(out)
+      if pages.size == 1
+        File.write(out, pages.first, mode: "wb")
+      else
+        pages.each_with_index do |page, i|
+          fn = File.basename(out, ".*") + "_{{n}}" + File.extname(out) unless out.include?("{{n}}")
+          fn = fn.gsub("{{n}}", (i+1).to_s)
+          File.write(fn, page, mode: "wb")
+        end
+      end
+    end
+
+    def pages
+      bytes.collect{ |page| page.pack("C*").to_s }
+    end
+
+    def document
+      pages.size == 1 ? pages.first : pages
+    end
+  end
+end

data/lib/formats/html.rb

@@ -0,0 +1,35 @@
+module Typst
+  class Html < Base
+    def initialize(*options)
+      super(*options)
+      title = CGI::escapeHTML(@options[:title] || File.basename(@options[:file], ".*"))
+      @compiled = HtmlDocument.new(Typst::_to_svg(*self.typst_args), title)
+    end
+  end
+
+  class HtmlDocument < Document
+    attr_accessor :title
+
+    def initialize(bytes, title)
+      super(bytes)
+      self.title = title
+    end
+
+    def markup
+      %{
+  <!DOCTYPE html>
+  <html>
+  <head>
+  <title>#{title}</title>
+  </head>
+  <body>
+  #{pages.join("<br />")}
+  </body>
+  </html>
+      }
+    end
+    alias_method :document, :markup
+  end
+
+  register_format(html: Html)
+end

data/lib/formats/html_experimental.rb

@@ -0,0 +1,11 @@
+module Typst
+  class HtmlExperimental < Base
+    def initialize(*options)
+      super(*options)
+      @compiled = HtmlExperimentalDocument.new(Typst::_to_html(*self.typst_args))
+    end
+  end
+  class HtmlExperimentalDocument < Document; end
+
+  register_format(html_experimental: HtmlExperimental)
+end

data/lib/formats/pdf.rb

@@ -0,0 +1,11 @@
+module Typst
+  class Pdf < Base
+    def initialize(*options)
+      super(*options)
+      @compiled = PdfDocument.new(Typst::_to_pdf(*self.typst_args))
+    end
+  end
+  class PdfDocument < Document; end
+
+  register_format(pdf: Pdf)
+end

data/lib/formats/png.rb

@@ -0,0 +1,11 @@
+module Typst
+  class Png < Base
+    def initialize(*options)
+      super(*options)
+      @compiled = PngDocument.new(Typst::_to_png(*self.typst_args))
+    end
+  end
+  class PngDocument < Document; end
+
+  register_format(png: Png)
+end

data/lib/formats/svg.rb

@@ -0,0 +1,11 @@
+module Typst
+  class Svg < Base
+    def initialize(*options)
+      super(*options)
+      @compiled = SvgDocument.new(Typst::_to_svg(*self.typst_args))
+    end
+  end
+  class SvgDocument < Document; end
+
+  register_format(svg: Svg)
+end

data/lib/query.rb

@@ -0,0 +1,19 @@
+module Typst
+  class Query < Base
+    attr_accessor :format
+
+    def initialize(selector, input, field: nil, one: false, format: "json", root: ".", font_paths: [], sys_inputs: {})
+      super(input, root: root, font_paths: font_paths, sys_inputs: sys_inputs)
+      self.format = format
+      @result = Typst::_query(selector, field, one, format, input, root, font_paths, File.dirname(__FILE__), false, sys_inputs)
+    end
+
+    def result(raw: false)
+      case raw || format
+        when "json" then JSON(@result)
+        when "yaml" then YAML::safe_load(@result)
+        else @result
+      end
+    end
+  end
+end