feat: generate css from theme

Cargo.lock

@@ -1427,7 +1427,6 @@ dependencies = [
  "tar",
  "time",
  "tokio",
- "toml",
  "tower-http",
  "tracing",
  "tracing-subscriber",

Cargo.toml

@@ -28,4 +28,3 @@ typst-utils = "0.15.1"
 tree-house = "0.4.0"
 tree-house-bindings = { version = "0.3.2", features = ["ropey"] }
 ropey = "1.6.1"
-toml = "0.8.23"

src/main.rs

@@ -69,6 +69,11 @@ struct AppConfig {
     #[arg(short = 't', long, value_name = "DIR", default_value = None)]
     themes_root: Option<PathBuf>,
 
+    /// Grammars to load, separated by commas.
+    /// Useful to avoid the memory required to load all languages.
+    #[arg(short = 'L', long = "lang", value_name = "NAME", value_delimiter = ',')]
+    languages: Vec<String>,
+
     /// The log level to use
     #[arg(short = 'l', long, value_name = "LEVEL", default_value_t = Level::INFO)]
     log_level: Level,

src/syntax.rs

@@ -1,10 +1,10 @@
 use std::{
     borrow::Cow,
-    collections::{BTreeSet, HashMap},
+    collections::{HashMap, HashSet},
     error::Error,
     fs,
-    path::{Path, PathBuf},
+    path::Path,
-    sync::{Arc, OnceLock, RwLock},
+    sync::OnceLock,
     time::Duration,
 };
 
@@ -24,18 +24,48 @@ use typst_html::{HtmlAttr, HtmlElem, attr, tag};
 
 use crate::AppConfig;
 
-/// Where grammars are loaded from, captured at `init`.
+static REGISTRY: OnceLock<LanguageRegistry> = OnceLock::new();
-static SYNTAX_ROOT: OnceLock<PathBuf> = OnceLock::new();
 
-/// LanguageRegistries keyed by ScopeSet
+/// Class names used in highlighted code.
-static REGISTRIES: OnceLock<RwLock<HashMap<BTreeSet<String>, Arc<LanguageRegistry>>>> =
+const HIGHLIGHT_NAMES: &[&str] = &[
-    OnceLock::new();
+    "attribute",
+    "comment",
+    "comment.block",
+    "comment.line",
+    "constant",
+    "constant.builtin",
+    "constructor",
+    "function",
+    "function.builtin",
+    "function.macro",
+    "function.method",
+    "keyword",
+    "keyword.control",
+    "keyword.operator",
+    "label",
+    "namespace",
+    "number",
+    "operator",
+    "property",
+    "punctuation",
+    "punctuation.bracket",
+    "punctuation.delimiter",
+    "special",
+    "string",
+    "string.special",
+    "tag",
+    "type",
+    "type.builtin",
+    "variable",
+    "variable.builtin",
+    "variable.parameter",
+];
 
-/// Get the index of the longest prefix of `scope` present in `scopes`.
+/// Get the longest matching highlight name for a given scope.
-fn highlight_for_scope(scope: &str, scopes: &[String]) -> Option<Highlight> {
+fn highlight_for_scope(scope: &str) -> Option<Highlight> {
     let mut candidate = scope;
     loop {
-        if let Some(i) = scopes.iter().position(|n| n == candidate) {
+        if let Some(i) = HIGHLIGHT_NAMES.iter().position(|&n| n == candidate) {
             return Some(Highlight::new(i as u32));
         }
         match candidate.rfind('.') {
@@ -46,89 +76,49 @@ fn highlight_for_scope(scope: &str, scopes: &[String]) -> Option<Highlight> {
 }
 
 struct LanguageRegistry {
-    syntax_root: PathBuf,
+    by_name: HashMap<String, Language>,
-    /// The scope vocabulary.
+    configs: Vec<LanguageConfig>,
-    scopes: Vec<String>,
-    /// Name to Language mapping, Option to allow storing None for failed
-    /// configuration and preventing reloading.
-    by_name: RwLock<HashMap<String, Option<Language>>>,
-    configs: RwLock<Vec<&'static LanguageConfig>>,
 }
 
 impl LanguageRegistry {
-    fn new(syntax_root: PathBuf, scopes: Vec<String>) -> Self {
+    /// Loads grammars from `syntax_root`. When `languages` is non-empty, only
-        Self {
+    /// grammars with those names are loaded; otherwise every grammar found is.
-            syntax_root,
+    fn new(syntax_root: &Path, languages: &[String]) -> Self {
-            scopes,
+        let filter: Option<HashSet<&str>> =
-            by_name: RwLock::new(HashMap::new()),
+            (!languages.is_empty()).then(|| languages.iter().map(String::as_str).collect());
-            configs: RwLock::new(Vec::new()),
+
+        let mut by_name = HashMap::new();
+        let mut configs = Vec::new();
+
+        for entry in fs::read_dir(syntax_root).into_iter().flatten().flatten() {
+            let name = entry.file_name().to_string_lossy().into_owned();
+            if filter.as_ref().is_some_and(|f| !f.contains(name.as_str())) {
+                continue;
             }
+            let so_path = entry.path().join(format!("{name}.so"));
+            if !so_path.exists() {
+                continue;
             }
 
-    /// The `Language` for `name`, loading and configuring its grammar on first
+            match load_language(&name, &entry.path(), syntax_root) {
-    /// request. Returns `None` if the grammar is missing or fails to load.
-    fn language(&self, name: &str) -> Option<Language> {
-        if let Some(cached) = self.by_name.read().unwrap().get(name) {
-            return *cached;
-        }
-
-        let loaded = self.load(name);
-
-        let mut by_name = self.by_name.write().unwrap();
-        if let Some(cached) = by_name.get(name) {
-            return *cached;
-        }
-        let language = loaded.map(|config| {
-            let mut configs = self.configs.write().unwrap();
-            configs.push(config);
-            Language::new((configs.len() - 1) as u32)
-        });
-        by_name.insert(name.to_owned(), language);
-        language
-    }
-
-    /// Loads and configures the grammar named `name`, leaking the config to a
-    /// `'static` borrow. `None` if the `.so` is absent or parsing fails.
-    fn load(&self, name: &str) -> Option<&'static LanguageConfig> {
-        let lang_dir = self.syntax_root.join(name);
-        if !lang_dir.join(format!("{name}.so")).exists() {
-            warn!("No grammar found for language {name}");
-            return None;
-        }
-        match load_language(name, &lang_dir, &self.syntax_root) {
                 Ok(config) => {
-                config.configure(|scope| highlight_for_scope(scope, &self.scopes));
+                    by_name.insert(name, Language::new(configs.len() as u32));
-                Some(Box::leak(Box::new(config)))
+                    configs.push(config);
                 }
-            Err(e) => {
+                Err(e) => warn!("Failed to load grammar {name}: {e}"),
-                warn!("Failed to load grammar {name}: {e}");
-                None
             }
         }
-    }
-}
-
-/// Fetch or build the registry configured for `scopes`.
-fn registry_for(scopes: BTreeSet<String>) -> Option<Arc<LanguageRegistry>> {
-    let registries = REGISTRIES.get()?;
-
-    // Fast path: already built.
-    if let Some(registry) = registries.read().unwrap().get(&scopes) {
-        return Some(registry.clone());
-    }
 
-    let syntax_root = SYNTAX_ROOT.get()?;
+        // Warn about explicitly requested grammars that were not found.
-    let ordered = scopes.iter().cloned().collect();
+        for lang in languages {
-    let registry = Arc::new(LanguageRegistry::new(syntax_root.clone(), ordered));
+            if !by_name.contains_key(lang) {
+                warn!("Requested grammar {lang} was not found in the syntax root");
+            }
+        }
 
-    Some(
+        info!("Loaded {} syntax highlighting grammars", configs.len());
-        registries
+        Self { by_name, configs }
-            .write()
+    }
-            .unwrap()
-            .entry(scopes)
-            .or_insert(registry)
-            .clone(),
-    )
 }
 
 fn load_language(
@@ -151,6 +141,7 @@ fn load_language(
         &read("injections"),
         &read("locals"),
     )?;
+    config.configure(highlight_for_scope);
 
     Ok(config)
 }
@@ -158,17 +149,17 @@ fn load_language(
 impl LanguageLoader for LanguageRegistry {
     fn language_for_marker(&self, marker: InjectionLanguageMarker<'_>) -> Option<Language> {
         match marker {
-            InjectionLanguageMarker::Name(name) => self.language(name),
+            InjectionLanguageMarker::Name(name) => self.by_name.get(name).copied(),
             InjectionLanguageMarker::Match(text) => {
                 let name: Cow<str> = text.into();
-                self.language(name.as_ref())
+                self.by_name.get(name.as_ref()).copied()
             }
             _ => None,
         }
     }
 
     fn get_config(&self, lang: Language) -> Option<&LanguageConfig> {
-        self.configs.read().unwrap().get(lang.idx()).copied()
+        self.configs.get(lang.idx())
     }
 }
 
@@ -176,8 +167,7 @@ pub fn init(config: &AppConfig) {
     match &config.syntax_root {
         Some(syntax_root) => {
             info!("Loading syntax files from {}", syntax_root.display());
-            SYNTAX_ROOT.get_or_init(|| syntax_root.clone());
+            REGISTRY.get_or_init(|| LanguageRegistry::new(syntax_root, &config.languages));
-            REGISTRIES.get_or_init(|| RwLock::new(HashMap::new()));
         }
         None => {
             warn!(
@@ -200,15 +190,8 @@ fn highlight(
     #[named]
     #[default(None)]
     lang: Option<String>,
-    #[named]
-    #[default(None)]
-    light: Option<String>,
-    #[named]
-    #[default(None)]
-    dark: Option<String>,
 ) -> Content {
-    let highlighted = highlight_code(&text, lang.as_deref(), light.as_deref(), dark.as_deref())
+    let highlighted = highlight_code(&text, lang.as_deref()).unwrap_or(TextElem::packed(text));
-        .unwrap_or_else(|| TextElem::packed(text));
 
     if block {
         HtmlElem::new(tag::pre)
@@ -224,25 +207,14 @@ fn highlight(
 }
 
 /// Highlights `source` as `lang`.
-fn highlight_code(
+fn highlight_code(source: &str, lang: Option<&str>) -> Option<Content> {
-    source: &str,
+    let registry = REGISTRY.get()?;
-    lang: Option<&str>,
+    let language = *registry.by_name.get(lang?)?;
-    light: Option<&str>,
-    dark: Option<&str>,
-) -> Option<Content> {
-    let (lang, light, dark) = (lang?, light?, dark?);
-    let Some(scopes) = crate::themes::shared_scopes(light, dark) else {
-        warn!("Unknown theme in pair (light={light}, dark={dark})");
-        return None;
-    };
-    let registry = registry_for(scopes)?;
-    let language = registry.language(lang)?;
 
     let rope = Rope::from_str(source);
     let slice = rope.slice(..);
-    let loader = registry.as_ref();
+    let syntax = Syntax::new(slice, language, Duration::from_millis(500), registry).ok()?;
-    let syntax = Syntax::new(slice, language, Duration::from_secs(3), loader).ok()?;
+    let mut hl = Highlighter::new(&syntax, slice, registry, 0..source.len() as u32);
-    let mut hl = Highlighter::new(&syntax, slice, loader, 0..source.len() as u32);
 
     let src = source.as_bytes();
     let src_len = source.len() as u32;
@@ -279,7 +251,7 @@ fn highlight_code(
             HighlightEvent::Push => classes.clone(),
         };
         classes = highlights.fold(base, |mut acc, h| {
-            let name = registry.scopes[h.idx()].replace('.', "-");
+            let name = HIGHLIGHT_NAMES[h.idx()].replace('.', "-");
             if !acc.is_empty() {
                 acc.push(' ');
             }

src/themes.rs

@@ -1,5 +1,6 @@
 use std::{
-    collections::{BTreeSet, HashMap, HashSet},
+    collections::{HashMap, HashSet},
+    error::Error,
     fs,
     path::Path,
     sync::OnceLock,
@@ -7,7 +8,10 @@ use std::{
 
 use toml::{Table, Value};
 use tracing::{info, warn};
-use typst::foundations::{Func, NativeFunc, func};
+use typst::{
+    foundations::{Content, Func, NativeElement, NativeFunc, func},
+    text::TextElem,
+};
 
 use crate::AppConfig;
 
@@ -82,13 +86,7 @@ impl ThemeRegistry {
 
         let themes = helix_themes
             .into_iter()
-            .flat_map(|(name, table)| match Theme::from_toml(table) {
+            .flat_map(|(name, table)| Theme::from_toml(table).map(|t| (name, t)))
-                Some(theme) => Some((name, theme)),
-                None => {
-                    warn!("Theme {name} is missing an `ui.background`, skipping it");
-                    None
-                }
-            })
             .collect();
 
         Self { themes }
@@ -110,13 +108,8 @@ impl Color {
     fn from_palette(color: &str, palette: &HashMap<String, Color>) -> Option<Self> {
         if color.starts_with('#') {
             Self::from_str(color)
-        } else if let Some(color) = palette.get(color) {
-            Some(color.clone())
         } else {
-            // Neither a hex literal nor a palette entry; assume a named CSS
+            palette.get(color).cloned()
-            // colour and pass it through verbatim.
-            warn!("Unresolved colour {color}, passing it through as a literal");
-            Some(Self(color.into()))
         }
     }
 }
@@ -225,21 +218,6 @@ pub fn init(config: &AppConfig) {
     }
 }
 
-/// The intersection of scopes between two themes.
-pub fn shared_scopes(light: &str, dark: &str) -> Option<BTreeSet<String>> {
-    let registry = REGISTRY.get()?;
-    let light = registry.themes.get(light)?;
-    let dark = registry.themes.get(dark)?;
-    Some(
-        light
-            .styles
-            .keys()
-            .filter(|k| dark.styles.contains_key(*k))
-            .cloned()
-            .collect(),
-    )
-}
-
 pub fn theme_css_func() -> Func {
     theme_css::func()
 }
@@ -273,28 +251,13 @@ fn style_declarations(style: &Style) -> String {
 }
 
 fn generate_css(scopes: &[&str], theme: &Theme) -> String {
-    let mut rules = Vec::new();
-
-    // The theme's editor foreground/background colour the code block itself.
-    let mut block_style = Vec::new();
-    if let Some(Color(hex)) = &theme.foreground {
-        block_style.push(format!("color:{hex}"));
-    }
-    if let Some(Color(hex)) = &theme.background {
-        block_style.push(format!("background:{hex}"));
-    }
-    if !block_style.is_empty() {
-        rules.push(format!(".code-block{{{}}}", block_style.join(";")));
-    }
-
     let mut groups: HashMap<&Style, Vec<&str>> = HashMap::new();
     for &scope in scopes {
         if let Some(style) = theme.styles.get(scope) {
             groups.entry(style).or_default().push(scope);
         }
     }
-
+    groups
-    let mut group_rules: Vec<String> = groups
         .iter()
         .map(|(style, scopes)| {
             let selectors = scopes
@@ -304,12 +267,8 @@ fn generate_css(scopes: &[&str], theme: &Theme) -> String {
                 .join(",");
             format!("{}{{{}}}", selectors, style_declarations(style))
         })
-        .collect();
+        .collect::<Vec<_>>()
-    // Sort so the emitted stylesheet is deterministic across runs.
+        .join("\n")
-    group_rules.sort();
-    rules.extend(group_rules);
-
-    rules.join("\n")
 }
 
 #[func]
@@ -326,8 +285,13 @@ fn theme_css(light: String, dark: String) -> String {
         return String::new();
     };
 
-    let shared = shared_scopes(&light, &dark).unwrap_or_default();
+    let mut shared: Vec<&str> = light_theme
-    let shared: Vec<&str> = shared.iter().map(String::as_str).collect();
+        .styles
+        .keys()
+        .filter(|k| dark_theme.styles.contains_key(*k))
+        .map(String::as_str)
+        .collect();
+    shared.sort();
 
     let light_css = generate_css(&shared, light_theme);
     let dark_css = generate_css(&shared, dark_theme);