From b382f9fae7a7722df9627114fb44aa7408dfe5fd Mon Sep 17 00:00:00 2001 From: danny Date: Wed, 14 Oct 2026 06:40:15 +0200 Subject: [PATCH] M0.6: command registry, guard, theme tokens, app.about and app.quit Command trait with static spec, enabled check and run; Registry rejects duplicate ids; Engine::execute runs every command inside the guard, which turns panics into EngineError::Internal and keeps the engine usable. Effects (Quit) are applied by the host. Theme tokens for Lutra Dark and Lutra Light render as --lt-* CSS variables and a webview init script. Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 26 +++++ crates/engine/Cargo.toml | 3 + crates/engine/src/cmd/app.rs | 53 +++++++++ crates/engine/src/cmd/mod.rs | 15 +++ crates/engine/src/command.rs | 111 +++++++++++++++++++ crates/engine/src/engine.rs | 202 ++++++++++++++++++++++++++++++++++ crates/engine/src/error.rs | 82 ++++++++++++++ crates/engine/src/guard.rs | 59 ++++++++++ crates/engine/src/lib.rs | 19 +++- crates/engine/src/registry.rs | 50 +++++++++ crates/engine/src/state.rs | 10 ++ crates/engine/src/theme.rs | 129 ++++++++++++++++++++++ 12 files changed, 758 insertions(+), 1 deletion(-) create mode 100644 crates/engine/src/cmd/app.rs create mode 100644 crates/engine/src/cmd/mod.rs create mode 100644 crates/engine/src/command.rs create mode 100644 crates/engine/src/engine.rs create mode 100644 crates/engine/src/error.rs create mode 100644 crates/engine/src/guard.rs create mode 100644 crates/engine/src/registry.rs create mode 100644 crates/engine/src/state.rs create mode 100644 crates/engine/src/theme.rs diff --git a/Cargo.lock b/Cargo.lock index 850e6bc..27ecb6c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -41,6 +41,11 @@ version = "0.0.0" [[package]] name = "lutra-engine" version = "0.0.0" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] [[package]] name = "lutra-index" @@ -109,6 +114,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" dependencies = [ "serde_core", + "serde_derive", ] [[package]] @@ -164,6 +170,26 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "toml" version = "1.1.8+spec-1.1.0" diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml index ec99325..b137e60 100644 --- a/crates/engine/Cargo.toml +++ b/crates/engine/Cargo.toml @@ -12,6 +12,9 @@ publish.workspace = true layer = 4 [dependencies] +serde = { version = "1.0.229", features = ["derive"] } +serde_json = "1.0.154" +thiserror = "2.0.21" [lints] workspace = true diff --git a/crates/engine/src/cmd/app.rs b/crates/engine/src/cmd/app.rs new file mode 100644 index 0000000..3be3d7a --- /dev/null +++ b/crates/engine/src/cmd/app.rs @@ -0,0 +1,53 @@ +//! Application commands: `app.about` and `app.quit`. + +use serde_json::{Value, json}; + +use crate::{Command, CommandSpec, Effect, EngineError, Outcome, State}; + +/// Product name shown in the About window and window titles. +pub const PRODUCT_NAME: &str = "Lutra"; + +/// Product slogan. +pub const SLOGAN: &str = "An otterly perfect IDE"; + +/// `app.about`: returns the product name, version and slogan. +pub struct About; + +impl Command for About { + fn spec(&self) -> &CommandSpec { + &CommandSpec { + id: "app.about", + label: "About Lutra", + menu_path: Some("Help/About Lutra"), + default_shortcut: None, + params: "none; returns { name, version, slogan }", + } + } + + fn run(&self, _state: &mut State, _params: Value) -> Result { + Ok(Outcome::value(json!({ + "name": PRODUCT_NAME, + "version": env!("CARGO_PKG_VERSION"), + "slogan": SLOGAN, + }))) + } +} + +/// `app.quit`: asks the host to quit the application. +pub struct Quit; + +impl Command for Quit { + fn spec(&self) -> &CommandSpec { + &CommandSpec { + id: "app.quit", + label: "Quit", + menu_path: Some("File/Quit"), + default_shortcut: Some("Mod+Q"), + params: "none; returns null and the effect quit", + } + } + + fn run(&self, _state: &mut State, _params: Value) -> Result { + Ok(Outcome::effect(Effect::Quit)) + } +} diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs new file mode 100644 index 0000000..debbcf4 --- /dev/null +++ b/crates/engine/src/cmd/mod.rs @@ -0,0 +1,15 @@ +//! Built-in commands, one module per area. + +mod app; + +use crate::{EngineError, Registry}; + +/// Registers every built-in command. +/// +/// # Errors +/// Returns [`EngineError::Internal`] if two commands share an id. +pub fn register_builtins(registry: &mut Registry) -> Result<(), EngineError> { + registry.register(Box::new(app::About))?; + registry.register(Box::new(app::Quit))?; + Ok(()) +} diff --git a/crates/engine/src/command.rs b/crates/engine/src/command.rs new file mode 100644 index 0000000..89eb3e4 --- /dev/null +++ b/crates/engine/src/command.rs @@ -0,0 +1,111 @@ +//! The command abstraction: static metadata, the run contract and the +//! effects a command asks its host to carry out. + +use serde::Serialize; +use serde_json::Value; + +use crate::{EngineError, State}; + +/// Static metadata of a command. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CommandSpec { + /// Unique id, `area.action` in camelCase, e.g. `app.about`. + pub id: &'static str, + /// Label for menus and the command palette, in English. + pub label: &'static str, + /// Menu path with `/` separators, e.g. `Help/About Lutra`. + pub menu_path: Option<&'static str>, + /// Default shortcut in Lutra notation; `Mod` is Ctrl, or Cmd on macOS. + pub default_shortcut: Option<&'static str>, + /// Documentation of the params object, `none` if the command takes none. + pub params: &'static str, +} + +/// Something the engine asks its host to do after a command returns, +/// because it needs a layer the engine cannot reach (windows, the process). +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +#[serde(tag = "kind", rename_all = "camelCase")] +pub enum Effect { + /// Quit the application. + Quit, +} + +/// Result of a successful command. +#[derive(Debug, Clone, PartialEq, Default)] +pub struct Outcome { + /// JSON result returned to the caller. + pub value: Value, + /// Effects for the host to apply, in order. + pub effects: Vec, +} + +impl Outcome { + /// An outcome with a value and no effects. + pub fn value(value: Value) -> Self { + Self { + value, + effects: Vec::new(), + } + } + + /// An outcome with a null value and one effect. + pub fn effect(effect: Effect) -> Self { + Self { + value: Value::Null, + effects: vec![effect], + } + } +} + +/// A user-visible action. +/// +/// Implementations are stateless; everything they change lives in [`State`]. +pub trait Command: Send + Sync { + /// Static metadata. + fn spec(&self) -> &CommandSpec; + + /// Whether the command can run in the given state. Defaults to always. + fn enabled(&self, _state: &State) -> bool { + true + } + + /// Runs the command. + /// + /// # Errors + /// Returns [`EngineError::InvalidParams`] for params that don't match + /// [`CommandSpec::params`], and [`EngineError::Failed`] when the action + /// itself fails. + fn run(&self, state: &mut State, params: Value) -> Result; +} + +/// Description of a command for menus, the palette, keymaps and agents. +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct CommandInfo { + /// Command id. + pub id: String, + /// Label. + pub label: String, + /// Menu path, if the command is in a menu. + pub menu_path: Option, + /// Default shortcut, if any. + pub default_shortcut: Option, + /// Params documentation. + pub params: String, + /// Whether the command can run in the current state. + pub enabled: bool, +} + +impl CommandInfo { + /// Builds the description from a spec and the current enabled state. + pub fn new(spec: &CommandSpec, enabled: bool) -> Self { + Self { + id: spec.id.to_string(), + label: spec.label.to_string(), + menu_path: spec.menu_path.map(str::to_string), + default_shortcut: spec.default_shortcut.map(str::to_string), + params: spec.params.to_string(), + enabled, + } + } +} diff --git a/crates/engine/src/engine.rs b/crates/engine/src/engine.rs new file mode 100644 index 0000000..c59bf8c --- /dev/null +++ b/crates/engine/src/engine.rs @@ -0,0 +1,202 @@ +//! The engine: registry plus state, and the one entry point that runs +//! commands. + +use serde_json::Value; + +use crate::{Command, CommandInfo, EngineError, Outcome, Registry, State, cmd, guard}; + +/// The command registry together with the workspace state. +/// +/// Hosts keep one engine behind a lock and call [`Engine::execute`] for every +/// action, whatever its origin (menu, shortcut, palette, CLI, control +/// channel, MCP). +pub struct Engine { + /// Registered commands. + registry: Registry, + /// Workspace state. + state: State, +} + +impl Engine { + /// An engine with the built-in commands. + /// + /// # Errors + /// Returns [`EngineError::Internal`] if two built-in commands share an id. + pub fn new() -> Result { + let mut engine = Self::empty(); + cmd::register_builtins(&mut engine.registry)?; + Ok(engine) + } + + /// An engine without any commands, for tests and embedding. + pub fn empty() -> Self { + Self { + registry: Registry::default(), + state: State::default(), + } + } + + /// Adds a command. + /// + /// # Errors + /// Returns [`EngineError::Internal`] if the id is already taken. + pub fn register(&mut self, command: Box) -> Result<(), EngineError> { + self.registry.register(command) + } + + /// Runs a command inside the guard. + /// + /// # Errors + /// [`EngineError::UnknownCommand`] for an unknown id, + /// [`EngineError::Disabled`] if the command is disabled, the command's own + /// error, or [`EngineError::Internal`] if it panicked. + pub fn execute(&mut self, id: &str, params: Value) -> Result { + let Self { registry, state } = self; + let command = registry + .get(id) + .ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?; + let result = guard::run(|| { + if !command.enabled(state) { + return Err(EngineError::Disabled(id.to_string())); + } + command.run(state, params) + }); + state.commands_run = state.commands_run.saturating_add(1); + result + } + + /// Describes every command with its current enabled state. A command whose + /// `enabled` check panics is listed as disabled. + pub fn list_commands(&self) -> Vec { + self.registry + .iter() + .map(|c| { + let enabled = guard::run(|| Ok(c.enabled(&self.state))).unwrap_or(false); + CommandInfo::new(c.spec(), enabled) + }) + .collect() + } + + /// Read access to the state. + pub fn state(&self) -> &State { + &self.state + } +} + +#[cfg(test)] +mod tests { + use serde_json::json; + + use super::*; + use crate::{CommandSpec, Effect}; + + struct Panicking; + + impl Command for Panicking { + fn spec(&self) -> &CommandSpec { + &CommandSpec { + id: "test.panic", + label: "Panic", + menu_path: None, + default_shortcut: None, + params: "none", + } + } + + fn run(&self, state: &mut State, _params: Value) -> Result { + state.commands_run += 100; + panic!("index out of bounds"); + } + } + + struct Disabled; + + impl Command for Disabled { + fn spec(&self) -> &CommandSpec { + &CommandSpec { + id: "test.disabled", + label: "Disabled", + menu_path: None, + default_shortcut: None, + params: "none", + } + } + + fn enabled(&self, _state: &State) -> bool { + false + } + + fn run(&self, _state: &mut State, _params: Value) -> Result { + Ok(Outcome::default()) + } + } + + #[test] + fn about_reports_product_information() { + let mut engine = Engine::new().unwrap(); + let out = engine.execute("app.about", Value::Null).unwrap(); + assert_eq!(out.value["name"], "Lutra"); + assert_eq!(out.value["slogan"], "An otterly perfect IDE"); + assert_eq!(out.value["version"], env!("CARGO_PKG_VERSION")); + assert!(out.effects.is_empty()); + } + + #[test] + fn quit_asks_the_host_to_quit() { + let mut engine = Engine::new().unwrap(); + let out = engine.execute("app.quit", json!({})).unwrap(); + assert_eq!(out.effects, vec![Effect::Quit]); + } + + #[test] + fn unknown_and_disabled_commands_fail() { + let mut engine = Engine::new().unwrap(); + engine.register(Box::new(Disabled)).unwrap(); + assert_eq!( + engine.execute("nope", Value::Null).unwrap_err().code(), + "unknown_command" + ); + assert_eq!( + engine + .execute("test.disabled", Value::Null) + .unwrap_err() + .code(), + "disabled" + ); + } + + #[test] + fn guard_survives_a_panicking_command() { + let mut engine = Engine::new().unwrap(); + engine.register(Box::new(Panicking)).unwrap(); + let err = engine.execute("test.panic", Value::Null).unwrap_err(); + assert_eq!(err, EngineError::Internal("index out of bounds".into())); + assert!(engine.execute("app.about", Value::Null).is_ok()); + assert_eq!(engine.state().commands_run, 102); + } + + #[test] + fn duplicate_ids_are_rejected() { + let mut engine = Engine::new().unwrap(); + engine.register(Box::new(Disabled)).unwrap(); + assert_eq!( + engine.register(Box::new(Disabled)).unwrap_err().code(), + "internal" + ); + } + + #[test] + fn lists_commands_with_metadata() { + let mut engine = Engine::new().unwrap(); + engine.register(Box::new(Disabled)).unwrap(); + let list = engine.list_commands(); + let ids: Vec<_> = list.iter().map(|c| c.id.as_str()).collect(); + assert_eq!(ids, vec!["app.about", "app.quit", "test.disabled"]); + let quit = &list[1]; + assert_eq!(quit.default_shortcut.as_deref(), Some("Mod+Q")); + assert!(quit.enabled); + assert!(!list[2].enabled); + let json = serde_json::to_value(quit).unwrap(); + assert_eq!(json["menuPath"], "File/Quit"); + } +} diff --git a/crates/engine/src/error.rs b/crates/engine/src/error.rs new file mode 100644 index 0000000..8c4d9af --- /dev/null +++ b/crates/engine/src/error.rs @@ -0,0 +1,82 @@ +//! The error type every engine entry point returns. + +use serde::Serialize; + +/// Why a command could not run or failed. +/// +/// Each variant has a stable [`code`](EngineError::code) that the control +/// channel, MCP and the frontend use to tell errors apart. +#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] +pub enum EngineError { + /// No command is registered under the id. + #[error("unknown command: {0}")] + UnknownCommand(String), + /// The command exists but is disabled in the current state. + #[error("command is not available right now: {0}")] + Disabled(String), + /// The params do not match the command's documented schema. + #[error("invalid params for {command}: {message}")] + InvalidParams { + /// The command id. + command: String, + /// What is wrong with the params. + message: String, + }, + /// The command ran and failed, e.g. a file could not be read. + #[error("{0}")] + Failed(String), + /// A bug: a command panicked or reached a state it should not. The guard + /// reports panics with this variant. + #[error("internal error: {0}")] + Internal(String), +} + +impl EngineError { + /// Stable machine-readable code of the error. + pub fn code(&self) -> &'static str { + match self { + Self::UnknownCommand(_) => "unknown_command", + Self::Disabled(_) => "disabled", + Self::InvalidParams { .. } => "invalid_params", + Self::Failed(_) => "failed", + Self::Internal(_) => "internal", + } + } + + /// The error as a `{ code, message }` payload for IPC and the control + /// channel. + pub fn payload(&self) -> ErrorPayload { + ErrorPayload { + code: self.code().to_string(), + message: self.to_string(), + } + } +} + +/// Serialisable form of an [`EngineError`]. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, serde::Deserialize)] +pub struct ErrorPayload { + /// Stable code, see [`EngineError::code`]. + pub code: String, + /// Message for the user. + pub message: String, +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn codes_are_stable() { + assert_eq!( + EngineError::UnknownCommand("x".into()).code(), + "unknown_command" + ); + let e = EngineError::InvalidParams { + command: "a.b".into(), + message: "missing path".into(), + }; + assert_eq!(e.payload().code, "invalid_params"); + assert_eq!(e.payload().message, "invalid params for a.b: missing path"); + } +} diff --git a/crates/engine/src/guard.rs b/crates/engine/src/guard.rs new file mode 100644 index 0000000..64e4d6f --- /dev/null +++ b/crates/engine/src/guard.rs @@ -0,0 +1,59 @@ +//! The last line of defence against bugs: turns a panic at an entry point +//! into [`EngineError::Internal`] so that the process, and the user's unsaved +//! work, survive. +//! +//! The guard is for bugs. Expected failures are `Result`s and never reach it. +//! Release builds keep `panic = "unwind"`, which this module relies on. + +use std::any::Any; +use std::panic::{AssertUnwindSafe, catch_unwind}; + +use crate::EngineError; + +/// Runs `f` and converts a panic inside it into [`EngineError::Internal`]. +/// +/// The closure is treated as unwind safe: after a panic the engine state may +/// hold a half-finished change from the failed command, which is preferable to +/// losing every open buffer. +/// +/// # Errors +/// Returns the closure's own error, or [`EngineError::Internal`] with the +/// panic message if it panicked. +pub fn run(f: impl FnOnce() -> Result) -> Result { + catch_unwind(AssertUnwindSafe(f)) + .unwrap_or_else(|payload| Err(EngineError::Internal(panic_message(payload.as_ref())))) +} + +/// Extracts the message of a panic payload, which is a `&str` or a `String` +/// for `panic!` with a literal or a format string. +fn panic_message(payload: &(dyn Any + Send)) -> String { + if let Some(s) = payload.downcast_ref::<&str>() { + (*s).to_string() + } else if let Some(s) = payload.downcast_ref::() { + s.clone() + } else { + "a command panicked".to_string() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn passes_results_through() { + assert_eq!(run(|| Ok(3)), Ok(3)); + assert_eq!( + run::<()>(|| Err(EngineError::Failed("no".into()))), + Err(EngineError::Failed("no".into())) + ); + } + + #[test] + fn converts_panics() { + let r = run::<()>(|| panic!("boom {}", 42)); + assert_eq!(r, Err(EngineError::Internal("boom 42".into()))); + let r = run::<()>(|| std::panic::panic_any(7_u8)); + assert_eq!(r, Err(EngineError::Internal("a command panicked".into()))); + } +} diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 24c2e15..02c4770 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -1,4 +1,21 @@ //! Engine of Lutra (layer L4). //! //! Owns the command registry, the workspace state, the panic guard around every -//! entry point and the crash-recovery journal. +//! entry point and the crash-recovery journal. Every user-visible action is a +//! [`Command`]; menus, the palette, shortcuts, the CLI, the control channel and +//! MCP all reach it through [`Engine::execute`]. + +pub mod cmd; +mod command; +mod engine; +mod error; +pub mod guard; +mod registry; +mod state; +pub mod theme; + +pub use command::{Command, CommandInfo, CommandSpec, Effect, Outcome}; +pub use engine::Engine; +pub use error::{EngineError, ErrorPayload}; +pub use registry::Registry; +pub use state::State; diff --git a/crates/engine/src/registry.rs b/crates/engine/src/registry.rs new file mode 100644 index 0000000..d48fd92 --- /dev/null +++ b/crates/engine/src/registry.rs @@ -0,0 +1,50 @@ +//! The command registry, keyed by command id. + +use std::collections::BTreeMap; + +use crate::{Command, EngineError}; + +/// All registered commands, in id order. +#[derive(Default)] +pub struct Registry { + /// Commands by id. + commands: BTreeMap<&'static str, Box>, +} + +impl Registry { + /// Adds a command. + /// + /// # Errors + /// Returns [`EngineError::Internal`] if the id is already taken; two + /// commands with one id is a programming error. + pub fn register(&mut self, command: Box) -> Result<(), EngineError> { + let id = command.spec().id; + if self.commands.contains_key(id) { + return Err(EngineError::Internal(format!( + "command registered twice: {id}" + ))); + } + self.commands.insert(id, command); + Ok(()) + } + + /// Looks a command up by id. + pub fn get(&self, id: &str) -> Option<&dyn Command> { + self.commands.get(id).map(Box::as_ref) + } + + /// Iterates over the commands in id order. + pub fn iter(&self) -> impl Iterator { + self.commands.values().map(Box::as_ref) + } + + /// Number of registered commands. + pub fn len(&self) -> usize { + self.commands.len() + } + + /// Whether no command is registered. + pub fn is_empty(&self) -> bool { + self.commands.is_empty() + } +} diff --git a/crates/engine/src/state.rs b/crates/engine/src/state.rs new file mode 100644 index 0000000..e333a87 --- /dev/null +++ b/crates/engine/src/state.rs @@ -0,0 +1,10 @@ +//! Workspace state that commands read and change. + +/// Everything the engine knows about the running session. +/// +/// Empty in milestone M0; M1 adds the open project, buffers and settings. +#[derive(Debug, Default)] +pub struct State { + /// Number of commands that ran to completion, successful or not. + pub commands_run: u64, +} diff --git a/crates/engine/src/theme.rs b/crates/engine/src/theme.rs new file mode 100644 index 0000000..c859d12 --- /dev/null +++ b/crates/engine/src/theme.rs @@ -0,0 +1,129 @@ +//! Theme tokens: the single source of every colour and font in the UI. +//! +//! Themes are defined here in Rust and rendered as CSS custom properties +//! (`--lt-`). Frontend components use only `var(--lt-…)`. The palettes +//! are Lutra's own: warm otter browns with a copper accent. + +/// A named set of token values. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct Theme { + /// Stable id used in settings, e.g. `lutra-dark`. + pub id: &'static str, + /// Display name. + pub name: &'static str, + /// Whether the theme is dark, for the window chrome and `color-scheme`. + pub dark: bool, + /// Token names (without the `--lt-` prefix) and CSS values. + pub tokens: &'static [(&'static str, &'static str)], +} + +/// Tokens shared by every theme (fonts and sizes). +const COMMON: &[(&str, &str)] = &[ + ( + "font-ui", + "system-ui, -apple-system, \"Segoe UI\", Roboto, Ubuntu, sans-serif", + ), + ( + "font-mono", + "ui-monospace, \"Cascadia Code\", Menlo, Consolas, monospace", + ), + ("font-size-ui", "13px"), + ("font-size-small", "12px"), +]; + +/// The default dark theme. +pub const DARK: Theme = Theme { + id: "lutra-dark", + name: "Lutra Dark", + dark: true, + tokens: &[ + ("bg", "#1f1d1b"), + ("editor-bg", "#191817"), + ("fg", "#e6e1da"), + ("fg-muted", "#9a928a"), + ("border", "#34302c"), + ("accent", "#d39a5c"), + ("error", "#ef7b6c"), + ("statusbar-bg", "#24211f"), + ("statusbar-fg", "#b8afa6"), + ], +}; + +/// The light theme. +pub const LIGHT: Theme = Theme { + id: "lutra-light", + name: "Lutra Light", + dark: false, + tokens: &[ + ("bg", "#f4f1ec"), + ("editor-bg", "#fbfaf8"), + ("fg", "#2a2622"), + ("fg-muted", "#7a7168"), + ("border", "#ddd6cd"), + ("accent", "#a8662a"), + ("error", "#c2412f"), + ("statusbar-bg", "#ece7e0"), + ("statusbar-fg", "#5a5149"), + ], +}; + +/// Every built-in theme. +pub const BUILTIN: &[Theme] = &[DARK, LIGHT]; + +/// Looks a built-in theme up by id. +pub fn by_id(id: &str) -> Option { + BUILTIN.iter().copied().find(|t| t.id == id) +} + +/// Renders a theme as a `:root { … }` rule of CSS custom properties. +pub fn css_variables(theme: &Theme) -> String { + let mut css = String::from(":root {\n"); + css.push_str(&format!( + " color-scheme: {};\n", + if theme.dark { "dark" } else { "light" } + )); + for (name, value) in COMMON.iter().chain(theme.tokens) { + css.push_str(&format!(" --lt-{name}: {value};\n")); + } + css.push('}'); + css +} + +/// JavaScript that installs the theme's CSS as a `