🥮 mooncakes.io
    Sign in

    moonbit-design-tokens

    MoonBit-first design token parser, validator, and multi-target generator.

    design-tokens
    css
    json
    moonbit
    tooling
    Download zip
    Version
    0.1.1
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    34

    No dependencies

    #moonbit-design-tokens

    MoonBit-first design token parsing, validation, theme composition, and multi-target generation.

    Design tokens are a practical boundary between product design systems and UI code. This library keeps that boundary reviewable: a small text format is parsed into typed MoonBit values, checked with actionable diagnostics, and rendered to CSS custom properties, JSON records, MoonBit constants, or Markdown.

    #Core capabilities

    • Typed token model for colors, font sizes, spacing, radii, and shadows.
    • Line-aware pipe-delimited parser with structured parse problems.
    • Value validation for CSS color, length, and shadow forms.
    • Theme overlays, token matrices, fallback lookup, aliases, missing-reference detection, cycle detection, and before/after diffs.
    • Canonical names, stable ordering, duplicate detection, prefixing, renaming, token-set composition, and collection statistics.
    • CSS, minified CSS, scoped CSS, CSS layer, JSON, MoonBit, and Markdown output.
    • A build API that composes parsing, validation, alias diagnostics, and rendering for use in application build pipelines.
    • A reusable 4,000-token scale fixture for examples and throughput checks.

    #Quick start

    git clone https://github.com/wallll-wal6/moonbit-design-tokens.git
cd moonbit-design-tokens
moon check --deny-warn
moon test --deny-warn
moon run cmd/main

    ///|
    test "README example" {
      let tokens = [
        Token::color("brand-primary", "#4f46e5", description="Primary action"),
        Token::spacing("space-4", "16px", description="Default gap"),
      ]
      inspect(validate_all(tokens).length(), content="0")
      inspect(to_css(tokens).contains("--brand-primary: #4f46e5;"), content="true")
    }

    #CLI

    moon run cmd/main runs a deterministic demonstration over the scale fixture. It reports fixture size and validation status, then renders a compact sample to CSS, JSON, MoonBit constants, and Markdown. The core package remains pure MoonBit and can be embedded in another CLI or build pipeline.

    For application integration, build_tokens accepts the pipe-delimited format and returns typed tokens, parse diagnostics, validation diagnostics, alias diagnostics, and the selected output in one result. BuildOptions controls canonical ordering, alias resolution, and the output format.

    #Architecture

    AreaFilesResponsibility
    Model and renderersmoonbit-design-tokens.mbtPublic types and output formats
    Parserparser.mbtText ingestion and source diagnostics
    Validationvalidation.mbtCSS-oriented value checks
    Operationsoperations.mbtSets, search, merge, diff, canonicalization
    Themesthemes.mbtOverlays, aliases, fallback, reports
    Build pipelinepipeline.mbtParse-to-output orchestration and diagnostics
    Scale fixturecatalog_*.mbtReusable deterministic fixture with 4,000 valid tokens
    CLIcmd/mainRunnable integration example

    #Benchmarks

    The repository records reproducible command timings and scale measurements in benchmarks/README.md. These are local observations, not universal performance claims or per-function microbenchmarks.

    #Tests and CI

    moon fmt --check
moon check --deny-warn
moon test --deny-warn --enable-coverage
moon test --target native --deny-warn
moon info

    GitHub Actions runs the quality gates on Ubuntu, macOS, and Windows, checks the stable toolchain, exercises the native backend, publishes coverage artifacts, and fails if generated public API information changes unexpectedly.

    #License

    Apache-2.0. See LICENSE.

    BuildOptions

    source
    pub(all) struct BuildOptions {
      canonicalize : Bool
      resolve_aliases : Bool
      output_format : OutputFormat
    } derive(Eq, 
    Debug    )

    BuildOptions::default

    source
    fn BuildOptions::default() -> BuildOptions

    BuildOptions::with_alias_resolution

    source
    fn BuildOptions::with_alias_resolution(self : BuildOptions, enabled : Bool) -> BuildOptions

    BuildOptions::with_format

    source
    fn BuildOptions::with_format(self : BuildOptions, output_format : OutputFormat) -> BuildOptions

    BuildOptions::without_canonicalization

    source
    fn BuildOptions::without_canonicalization(self : BuildOptions) -> BuildOptions

    BuildResult

    source
    pub struct BuildResult {
      tokens : Array[Token]
      parse_problems : Array[ParseProblem]
      token_problems : Array[TokenProblem]
      alias_problems : Array[String]
      output : String
      format : OutputFormat
    } derive(Eq, 
    Debug    )

    BuildResult::alias_problems

    source
    fn BuildResult::alias_problems(self : BuildResult) -> Array[String]

    BuildResult::diagnostics

    source
    fn BuildResult::diagnostics(self : BuildResult) -> String

    BuildResult::format

    source
    fn BuildResult::format(self : BuildResult) -> OutputFormat

    BuildResult::ok

    source
    fn BuildResult::ok(self : BuildResult) -> Bool

    BuildResult::output

    source
    fn BuildResult::output(self : BuildResult) -> String

    BuildResult::parse_problems

    source
    fn BuildResult::parse_problems(self : BuildResult) -> Array[ParseProblem]

    BuildResult::summary

    source
    fn BuildResult::summary(self : BuildResult) -> String

    BuildResult::token_problems

    source
    fn BuildResult::token_problems(self : BuildResult) -> Array[TokenProblem]

    BuildResult::tokens

    source
    fn BuildResult::tokens(self : BuildResult) -> Array[Token]

    OutputFormat

    source
    pub(all) enum OutputFormat {
      Css
      CssMinified
      Json
      JsonLines
      MoonBit
      Markdown
    } derive(Eq, 
    Debug    )

    OutputFormat::label

    source
    fn OutputFormat::label(self : OutputFormat) -> String

    ParseProblem

    source
    pub(all) enum ParseProblem {
      BadFieldCount(Int, String)
      UnknownKind(Int, String)
    } derive(Eq, 
    Debug    )

    ParseProblem::message

    source
    fn ParseProblem::message(self : ParseProblem) -> String

    ParseReport

    source
    pub(all) struct ParseReport {
      tokens : Array[Token]
      problems : Array[ParseProblem]
    } derive(Eq, 
    Debug    )

    Theme

    source
    pub struct Theme {
      name : String
      tokens : Array[Token]
    } derive(Eq, 
    Debug    )

    Theme::diff

    source
    fn Theme::diff(self : Theme, other : Theme) -> Array[TokenChange]

    Theme::get

    source
    fn Theme::get(self : Theme, name : String) -> Token?

    Theme::merge

    source
    fn Theme::merge(self : Theme, overlay : Theme) -> Theme

    Theme::name

    source
    fn Theme::name(self : Theme) -> String

    Theme::new

    source
    fn Theme::new(name~ : String, tokens~ : Array[Token]) -> Theme

    Theme::tokens

    source
    fn Theme::tokens(self : Theme) -> Array[Token]

    ThemeReport

    source
    pub struct ThemeReport {
      theme : String
      errors : Array[String]
      warnings : Array[String]
    } derive(Eq, 
    Debug    )

    ThemeReport::ok

    source
    fn ThemeReport::ok(self : ThemeReport) -> Bool

    ThemeReport::summary

    source
    fn ThemeReport::summary(self : ThemeReport) -> String

    Token

    source
    pub(all) struct Token {
      name : String
      kind : TokenKind
      value : String
      description : String
    } derive(Eq, 
    Debug    )

    Token::color

    source
    fn Token::color(name : String, value : String, description~ : String) -> Token

    Token::css_declaration

    source
    fn Token::css_declaration(self : Token) -> String

    Token::css_name

    source
    fn Token::css_name(self : Token) -> String

    Token::css_variable

    source
    fn Token::css_variable(self : Token) -> String

    Token::font_size

    source
    fn Token::font_size(name : String, value : String, description~ : String) -> Token

    Token::json_object

    source
    fn Token::json_object(self : Token) -> String

    Token::markdown_row

    source
    fn Token::markdown_row(self : Token) -> String

    Token::moonbit_const

    source
    fn Token::moonbit_const(self : Token) -> String

    Token::radius

    source
    fn Token::radius(name : String, value : String, description~ : String) -> Token

    Token::shadow

    source
    fn Token::shadow(name : String, value : String, description~ : String) -> Token

    Token::spacing

    source
    fn Token::spacing(name : String, value : String, description~ : String) -> Token

    Token::validate

    source
    fn Token::validate(self : Token) -> Array[TokenProblem]

    TokenChange

    source
    pub enum TokenChange {
      Added(Token)
      Removed(Token)
      Changed(Token, Token)
    } derive(Eq, 
    Debug    )

    TokenChange::kind

    source
    fn TokenChange::kind(self : TokenChange) -> String

    TokenChange::name

    source
    fn TokenChange::name(self : TokenChange) -> String

    TokenKind

    source
    pub(all) enum TokenKind {
      Color
      FontSize
      Spacing
      Radius
      Shadow
    } derive(Eq, 
    Debug    )

    TokenKind::label

    source
    fn TokenKind::label(self : TokenKind) -> String

    TokenProblem

    source
    pub(all) enum TokenProblem {
      EmptyName
      EmptyValue(String)
      UnsupportedColor(String, String)
      UnsupportedLength(String, String)
      UnsupportedShadow(String)
    } derive(Eq, 
    Debug    )

    TokenProblem::message

    source
    fn TokenProblem::message(self : TokenProblem) -> String

    TokenSet

    source
    pub struct TokenSet {
      name : String
      tokens : Array[Token]
    } derive(Eq, 
    Debug    )

    TokenSet::all

    source
    fn TokenSet::all(self : TokenSet) -> Array[Token]

    TokenSet::canonical

    source
    fn TokenSet::canonical(self : TokenSet) -> TokenSet

    TokenSet::diff

    source
    fn TokenSet::diff(self : TokenSet, other : TokenSet) -> Array[TokenChange]

    TokenSet::get

    source
    fn TokenSet::get(self : TokenSet, name : String) -> Token?

    TokenSet::merge

    source
    fn TokenSet::merge(self : TokenSet, overlay : TokenSet) -> TokenSet

    TokenSet::name

    source
    fn TokenSet::name(self : TokenSet) -> String

    TokenSet::new

    source
    fn TokenSet::new(name~ : String, tokens~ : Array[Token]) -> TokenSet

    TokenSet::render

    source
    fn TokenSet::render(self : TokenSet, format : OutputFormat) -> String

    TokenSet::size

    source
    fn TokenSet::size(self : TokenSet) -> Int

    TokenSet::valid

    source
    fn TokenSet::valid(self : TokenSet) -> Bool

    TokenSet::validate

    source
    fn TokenSet::validate(self : TokenSet) -> Array[TokenProblem]

    TokenSet::with_prefix

    source
    fn TokenSet::with_prefix(self : TokenSet, prefix : String) -> TokenSet

    TokenStats

    source
    pub(all) struct TokenStats {
      total : Int
      valid : Int
      aliases : Int
      duplicate_names : Int
      empty_values : Int
      longest_name : Int
      longest_value : Int
    } derive(Eq, 
    Debug    )

    TokenStats::aliases

    source
    fn TokenStats::aliases(self : TokenStats) -> Int

    TokenStats::duplicate_names

    source
    fn TokenStats::duplicate_names(self : TokenStats) -> Int

    TokenStats::empty_values

    source
    fn TokenStats::empty_values(self : TokenStats) -> Int

    TokenStats::longest_name

    source
    fn TokenStats::longest_name(self : TokenStats) -> Int

    TokenStats::longest_value

    source
    fn TokenStats::longest_value(self : TokenStats) -> Int

    TokenStats::summary

    source
    fn TokenStats::summary(self : TokenStats) -> String

    TokenStats::total

    source
    fn TokenStats::total(self : TokenStats) -> Int

    TokenStats::valid

    source
    fn TokenStats::valid(self : TokenStats) -> Int

    alias_cycles

    source
    fn alias_cycles(tokens : Array[Token]) -> Array[String]

    analyze_tokens

    source
    fn analyze_tokens(tokens : Array[Token]) -> TokenStats

    build_text

    source
    fn build_text(input : String, format~ : OutputFormat) -> BuildResult

    build_tokens

    source
    fn build_tokens(input : String, options~ : BuildOptions) -> BuildResult

    canonical_tokens

    source
    fn canonical_tokens(tokens : Array[Token]) -> Array[Token]

    catalog_by_kind

    source
    fn catalog_by_kind(kind : TokenKind) -> Array[Token]

    catalog_size

    source
    fn catalog_size() -> Int

    diff_summary

    source
    fn diff_summary(changes : Array[TokenChange]) -> String

    diff_tokens

    source
    fn diff_tokens(before : Array[Token], after : Array[Token]) -> Array[TokenChange]

    fallback_value

    source
    fn fallback_value(themes : Array[Theme], name : String, default : String) -> String

    find_token

    source
    fn find_token(tokens : Array[Token], name : String) -> Token?

    has_duplicate_names

    source
    fn has_duplicate_names(tokens : Array[Token]) -> Bool

    inspect_theme

    source
    fn inspect_theme(item : Theme) -> ThemeReport

    map_descriptions

    source
    fn map_descriptions(tokens : Array[Token], prefix : String) -> Array[Token]

    merge_tokens

    source
    fn merge_tokens(base : Array[Token], overlay : Array[Token]) -> Array[Token]

    normalize_name

    source
    fn normalize_name(name : String) -> String

    normalize_tokens

    source
    fn normalize_tokens(tokens : Array[Token]) -> Array[Token]

    parse_tokens

    source
    fn parse_tokens(input : String) -> ParseReport

    prefix_tokens

    source
    fn prefix_tokens(tokens : Array[Token], prefix : String) -> Array[Token]

    production_catalog

    source
    fn production_catalog() -> Array[Token]

    rename_token

    source
    fn rename_token(tokens : Array[Token], old_name : String, new_name : String) -> Array[Token]

    render_all

    source
    fn render_all(tokens : Array[Token]) -> String

    render_output

    source
    fn render_output(tokens : Array[Token], format : OutputFormat) -> String

    replace_token_reference

    source
    fn replace_token_reference(tokens : Array[Token], old_name : String, new_name : String) -> Array[Token]

    resolve_alias

    source
    fn resolve_alias(value : String, tokens : Array[Token]) -> String

    resolve_aliases

    source
    fn resolve_aliases(tokens : Array[Token]) -> Array[Token]

    sample_tokens

    source
    fn sample_tokens() -> Array[Token]

    sort_tokens_by_name

    source
    fn sort_tokens_by_name(tokens : Array[Token]) -> Array[Token]

    theme

    source
    fn theme(name~ : String, tokens~ : Array[Token]) -> Theme

    theme_css

    source
    fn theme_css(theme : Theme, selector : String) -> String

    theme_family

    source
    fn theme_family(base : Array[Token], light_overrides : Array[Token], dark_overrides : Array[Token]) -> Array[Theme]

    theme_switcher

    source
    fn theme_switcher(themes : Array[Theme], attribute : String) -> String

    theme_token_matrix

    source
    fn theme_token_matrix(themes : Array[Theme], names : Array[String]) -> Array[Array[String]]

    to_css

    source
    fn to_css(tokens : Array[Token]) -> String

    to_css_layer

    source
    fn to_css_layer(tokens : Array[Token], layer : String) -> String

    to_css_minified

    source
    fn to_css_minified(tokens : Array[Token]) -> String

    to_css_scoped

    source
    fn to_css_scoped(tokens : Array[Token], selector : String) -> String

    to_json

    source
    fn to_json(tokens : Array[Token]) -> String

    to_json_lines

    source
    fn to_json_lines(tokens : Array[Token]) -> String

    to_markdown_sorted

    source
    fn to_markdown_sorted(tokens : Array[Token]) -> String

    to_markdown_table

    source
    fn to_markdown_table(tokens : Array[Token]) -> String

    to_moonbit_constants

    source
    fn to_moonbit_constants(tokens : Array[Token]) -> String

    token_count_by_kind

    source
    fn token_count_by_kind(tokens : Array[Token], kind : TokenKind) -> Int

    token_names

    source
    fn token_names(tokens : Array[Token]) -> Array[String]

    token_names_with_prefix

    source
    fn token_names_with_prefix(tokens : Array[Token], prefix : String) -> Array[String]

    token_set

    source
    fn token_set(name~ : String, tokens~ : Array[Token]) -> TokenSet

    tokens_of_kind

    source
    fn tokens_of_kind(tokens : Array[Token], kind : TokenKind) -> Array[Token]

    tokens_referencing

    source
    fn tokens_referencing(tokens : Array[Token], name : String) -> Array[Token]

    tokens_with_prefix

    source
    fn tokens_with_prefix(tokens : Array[Token], prefix : String) -> Array[Token]

    unique_tokens

    source
    fn unique_tokens(tokens : Array[Token]) -> Array[Token]

    unresolved_aliases

    source
    fn unresolved_aliases(tokens : Array[Token]) -> Array[String]

    validate_all

    source
    fn validate_all(tokens : Array[Token]) -> Array[TokenProblem]

    validate_names

    source
    fn validate_names(tokens : Array[Token]) -> Array[String]

    validate_themes

    source
    fn validate_themes(themes : Array[Theme]) -> Array[ThemeReport]

    validate_unique_names

    source
    fn validate_unique_names(tokens : Array[Token]) -> Array[String]

    without_tokens

    source
    fn without_tokens(tokens : Array[Token], names : Array[String]) -> Array[Token]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io