1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
//! # `base16cs`
//!
//! A library for defining a **palette** of **base colors** in canonical CIE
//! L\*a\*b\* colorspace values, and then deriving other colorspace values from
//! them.
//!
//! This library also provides serializers and deserializers for palettes, and
//! a template renderer (Liquid, by default) for injecting palette and color
//! variables into a template for renders.
//!
//! ## Examples
//!
//! ### Defining a base palette and deriving computed color values
//!
//! ```rust
//! use base16cs::{Palette, BaseColor, DerivedPalette};
//!
//! // Define a canonical palette
//! let palette = Palette::new(
//! "My Palette",
//! [
//! BaseColor::new("bg", 96, 0, 13),
//! BaseColor::new("fg", 31, -6, -6),
//! ]);
//!
//! // Derive with computed sRGB values
//! let derived_palette = DerivedPalette::from(&palette);
//! assert_eq!(derived_palette.name, "My Palette");
//!
//! let derived_colors = &derived_palette.colors;
//! assert_eq!(derived_colors[0].base, &palette.colors[0]);
//! assert_eq!(derived_colors[1].base, &palette.colors[1]);
//!
//! assert_eq!(derived_colors[0].srgb_hex, "fef3da");
//! assert_eq!(derived_colors[1].srgb_hex, "384c52");
//! ```
//!
//! ### Serializing and deserializing a palette (YAML)
//!
//! This crate is compiled with YAML serde by default.
//!
//! ```rust
//! # use base16cs::{Palette, BaseColor, DerivedPalette};
//! use base16cs::Serializable;
//!
//! # let palette = Palette::new(
//! # "My Palette",
//! # [
//! # BaseColor::new("bg", 96, 0, 13),
//! # BaseColor::new("fg", 31, -6, -6),
//! # ]);
//! # let derived_palette = DerivedPalette::from(&palette);
//! let serialized = derived_palette.serialize().unwrap();
//! assert_eq!(serialized, r#"name: My Palette
//! colors:
//! - base:
//! name: bg
//! lab:
//! l: 96.0
//! a: 0.0
//! b: 13.0
//! srgb:
//! red: 254
//! green: 243
//! blue: 218
//! srgb_hex: fef3da
//! - base:
//! name: fg
//! lab:
//! l: 31.0
//! a: -6.0
//! b: -6.0
//! srgb:
//! red: 56
//! green: 76
//! blue: 82
//! srgb_hex: 384c52
//! "#);
//! ```
//!
//! Deserialization is always done from a *base* palette, since its derived form
//! can be re-computed at runtime.
//!
//! ```rust
//! # use base16cs::{Palette, BaseColor};
//! # use base16cs::Serializable;
//! # let palette = Palette::new(
//! # "My Palette",
//! # [
//! # BaseColor::new("bg", 96, 0, 13),
//! # BaseColor::new("fg", 31, -6, -6),
//! # ]);
//! let yaml_str = r#"
//! name: My Palette
//! colors:
//! - name: bg
//! lab:
//! l: 96.0
//! a: 0.0
//! b: 13.0
//! - name: fg
//! lab:
//! l: 31.0
//! a: -6.0
//! b: -6.0
//! "#;
//!
//! let de_palette = Palette::<2>::from_yaml(yaml_str).unwrap();
//! assert_eq!(de_palette, palette);
//! ```
//!
//! ### Injecting a palette into a template for render
//!
//! See: [`template`](template/mod.rs) module.
pub use Base16Colors;
pub use Base16DerivedColors;
pub use Base16DerivedPalette;
pub use Base16Palette;
pub use BaseColor;
pub use DerivedColor;
pub use DerivedPalette;
pub use Palette;
pub use yaml;
pub use Serializable;
pub use liquid;
pub use PaletteRenderer;
pub use RenderOptions;