API Reference

pub enum FontWeight {
    Thin        = 100,
    ExtraLight  = 200,
    Light       = 300,
    Regular     = 400,  // default
    Medium      = 500,
    SemiBold    = 600,
    Bold        = 700,
    ExtraBold   = 800,
    Black       = 900,
}

pub enum FontStyle {
    Normal,   // default
    Italic,
    Oblique,
}

pub struct FontSpec {
    pub family: String,
    pub fallbacks: Vec<String>,
    pub weight: FontWeight,
    pub style: FontStyle,
    pub size: Option<f32>,
}

pub struct FontRule {
    pub scope: String,
    pub font: FontSpec,
}

pub struct FontAssignment {
    pub scope: String,
    pub font: FontSpec,
    pub specificity: usize,
    pub is_active: bool,
}

pub struct TokenInfo {
    pub text: String,
    pub range: Range,
    pub scope: String,
    pub modifiers: Vec<String>,
}

pub struct Position {
    pub line: u32,
    pub column: u32,
}

pub struct Range {
    pub start: Position,
    pub end: Position,
}

pub struct TokenCollection {
    pub uri: String,
    pub language: String,
    pub tokens: Vec<TokenInfo>,
}

pub trait PolyfontEngine: Send + Sync {
    fn add_rule(&mut self, rule: FontRule);
    fn remove_rule(&mut self, scope: &str);
    fn rules(&self) -> &[FontRule];
    fn resolve_token(&self, token: &TokenInfo) -> Option<FontAssignment>;
    fn resolve_all(&self, tokens: &[TokenInfo]) -> Vec<Option<FontAssignment>>;
    fn clear(&mut self);
}

pub struct ScopeMatchEngine {
    // rules sorted by specificity descending
}

impl ScopeMatchEngine {
    pub const fn new() -> Self;
    pub fn from_rules(rules: Vec<FontRule>) -> Self;
    pub fn scope_matches(scope: &str, pattern: &str) -> bool;
}

pub enum PolyfontError {
    Config(String),
    FontNotFound(String),
    InvalidScope(String),
    Io(std::io::Error),
    Parse(String),
}

pub struct PolyfontConfig {
    pub version: u32,
    pub default: Option<DefaultFontConfig>,
    pub rules: Vec<RuleConfig>,
}

pub struct DefaultFontConfig {
    pub family: String,
    pub fallbacks: Vec<String>,
    pub weight: FontWeight,
    pub style: FontStyle,
    pub size: Option<f32>,
}

pub struct RuleConfig {
    pub scope: String,
    pub font: FontConfig,
}

pub struct FontConfig {
    pub family: String,
    pub fallbacks: Vec<String>,
    pub weight: FontWeight,
    pub style: FontStyle,
    pub size: Option<f32>,
}

pub struct ConfigLoader;

impl ConfigLoader {
    pub fn load_from_path(path: &Path) -> Result<PolyfontConfig, ConfigError>;
    pub fn load_from_dir(start_dir: &Path) -> Result<PolyfontConfig, ConfigError>;
    pub fn find_config(start_dir: &Path) -> Option<PathBuf>;
    pub fn load_merged(start_dir: &Path) -> Result<PolyfontConfig, ConfigError>;
}

pub enum ConfigError {
    UnsupportedVersion { found: u32, expected: u32 },
    Validation(String),
    Io(std::io::Error),
    Parse(toml::de::Error),
    NotFound(PathBuf),
}

pub struct ScopePattern { /* private fields */ }

impl ScopePattern {
    pub fn parse(pattern: &str) -> Result<Self, ScopeError>;
    pub fn matches_scope(&self, scope: &str) -> bool;
    pub fn specificity(&self) -> usize;
}

pub struct ScopeSelector { /* private fields */ }

impl ScopeSelector {
    pub fn parse(selector: &str) -> Result<Self, ScopeError>;
    pub fn matches(&self, scope: &str) -> bool;
    pub fn specificity(&self) -> usize;
}

pub struct ScopeMatcher;

impl ScopeMatcher {
    pub fn matches(scope: &str, selector: &str) -> Result<bool, ScopeError>;
    pub fn matches_any(scope: &str, selectors: &[&str]) -> Result<bool, ScopeError>;
}

pub struct ScopeResolver { /* private fields */ }

impl ScopeResolver {
    pub const fn new() -> Self;
    pub fn from_rules(rules: Vec<FontRule>) -> Self;
    pub fn add_rule(&mut self, rule: FontRule);
    pub fn resolve(&self, scope: &str) -> Option<ResolvedScope>;
    pub fn resolve_all<'a, I>(&self, scopes: I) -> Vec<Option<ResolvedScope>>;
    pub fn clear(&mut self);
    pub const fn rule_count(&self) -> usize;
}

pub struct ResolvedScope {
    pub assignment: FontAssignment,
    pub rule_index: usize,
}

pub struct ScopeTree { /* private fields */ }

impl ScopeTree {
    pub fn new() -> Self;
    pub fn insert(&mut self, scope: &str);
    pub fn contains(&self, scope: &str) -> bool;
    pub fn has_prefix(&self, prefix: &str) -> bool;
    pub fn query_prefix(&self, prefix: &str) -> Vec<String>;
    pub fn len(&self) -> usize;
    pub fn is_empty(&self) -> bool;
}

pub enum ScopeError {
    EmptyPattern,
    InvalidPattern(String),
}

pub const SCOPE_KEYWORD:     &str = "keyword";
pub const SCOPE_COMMENT:     &str = "comment";
pub const SCOPE_STRING:      &str = "string";
pub const SCOPE_FUNCTION:    &str = "entity.name.function";
pub const SCOPE_VARIABLE:    &str = "variable";
pub const SCOPE_CONSTANT:    &str = "constant";
pub const SCOPE_TYPE:        &str = "entity.name.type";
pub const SCOPE_NUMBER:      &str = "constant.numeric";
pub const SCOPE_OPERATOR:    &str = "keyword.operator";
pub const SCOPE_PUNCTUATION: &str = "punctuation";
pub const SCOPE_TAG:         &str = "entity.name.tag";
pub const SCOPE_ATTRIBUTE:   &str = "entity.other.attribute-name";

pub struct TokenParser { /* private fields */ }

impl TokenParser {
    pub fn new() -> Self;
    pub fn parse_tokens(
        &self,
        text: &str,
        language_id: &str,
        offset_encoding: OffsetEncoding,
    ) -> Result<Vec<TokenInfo>, ParseError>;
}

pub enum OffsetEncoding {
    Utf8,
    Utf16,
}

pub enum ParseError {
    UnsupportedLanguage(String),
    ParseFailed { language: String, message: String },
}

pub trait FontDiscovery: Send + Sync {
    fn list_families(&self) -> Result<Vec<String>, FontError>;
    fn find_family(&self, name: &str) -> Result<bool, FontError>;
    fn font_path(&self, name: &str) -> Option<PathBuf>;
}

pub struct FontScanner { /* private fields */ }

impl FontScanner {
    pub fn new() -> Self;
    pub fn with_discovery(discovery: Box<dyn FontDiscovery>) -> Self;
    pub fn is_available(&self, family: &str) -> bool;
    pub fn available_families(&self) -> Vec<String>;
    pub fn check_config(&self, families: &[&str]) -> FontCheckResult;
}

pub fn create_discovery() -> Box<dyn FontDiscovery>;

pub struct FontCheckResult {
    pub available: Vec<String>,
    pub missing: Vec<String>,
}

pub enum FontError {
    DiscoveryFailed(String),
    CommandFailed(String),
    ParseError,
}

pub struct ThemeImporter;

impl ThemeImporter {
    pub fn import_vscode(json: &str) -> Result<PolyfontConfig, ThemeError>;
    pub fn import_textmate(json: &str) -> Result<PolyfontConfig, ThemeError>;
}

pub struct ThemeExporter;

impl ThemeExporter {
    pub fn export_config(config: &PolyfontConfig) -> Result<String, ThemeError>;
    pub fn export_vscode(config: &PolyfontConfig) -> Result<String, ThemeError>;
}

pub struct ThemeRegistry;

impl ThemeRegistry {
    pub fn list() -> Vec<&'static str>;
    pub fn get(name: &str) -> Option<&'static BuiltinTheme>;
}

pub enum ThemeError {
    InvalidJson(String),
    MissingField(String),
    InvalidScope(String),
    ImportFailed(String),
    ExportFailed(String),
}

pub struct PolyfontLanguageServer { /* private fields */ }

impl PolyfontLanguageServer {
    pub fn new(client: Client) -> Self;
    pub fn build_service() -> (LspService<Self>, ClientSocket);
}

pub struct FontAssignmentNotification {
    pub uri: String,
    pub assignments: Vec<FontAssignmentEntry>,
}

pub struct FontAssignmentEntry {
    pub scope: String,
    pub range: LspRange,
    pub font: FontInfo,
}

pub struct FontInfo {
    pub family: String,
    pub fallbacks: Vec<String>,
    pub weight: String,
    pub style: String,
}

{ "uri": "file:///path/to/document.rs" }

pub struct LspRange {
    pub start: LspPosition,
    pub end: LspPosition,
}

pub struct LspPosition {
    pub line: u32,
    pub character: u32,
}