Merge pull request #13 from TickPoints/dev

Update to `0.1.8-alpha`

Author: TickPoints

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mdbook-plotly"
-version = "0.1.7"
+version = "0.1.8-alpha"
 authors = ["TickPoints <tickpoints@outlook.com>"]
 edition = "2024"
 keywords = ["markdown", "mdbook"]
@@ -40,5 +40,3 @@ lto = "fat"
 codegen-units = 1
 panic = "abort"
 strip = true
-# Only on alpha or beta.
-debug = true

Cargo.toml

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## v0.1.8-alpha
+- Adjusted `code_handler`
+    - Updated `map`
+- Fixed docs
+- Updated tests
+
 ## v0.1.7
 - Adjusted `code_handler`
     - Updated `map`

docs/CHANGELOG.md

@@ -188,7 +188,11 @@ offline_js_sources = false
 
 - **Rgb** – `"rgb(u8, u8, u8)"`（例如 `"rgb(0, 0, 0)"`）
 - **Rgba** – `"rgba(u8, u8, u8, f64)"`（例如 `"rgba(0, 0, 0, 0.0)"`）
-- **Color** – 可以是命名的 CSS 颜色（`{ named_color: "aliceblue" }`）、RGB 字符串或 RGBA 字符串。
+- **Color** – 可以是：
+  * 命名的 CSS 颜色：`{ named_color: "aliceblue" }`
+  * RGB 字符串：`"rgb(255, 0, 0)"`
+  * RGBA 字符串：`"rgba(255, 0, 0, 0.5)"`
+  * 或等效的对象形式：`{ rgb_color: "rgb(255,0,0)" }`、`{ rgba_color: "rgba(255,0,0,0.5)" }`
 
 ### 映射与生成器
 
@@ -300,6 +304,43 @@ offline_js_sources = false
   // 得到 [0.0, 0.25, 0.5, 0.75, 1.0]
   ```
 
+- **`if`** — 根据算术表达式的结果在两个值之间进行条件选择。
+
+  _参数：_
+  ```json5
+  {
+      type: "if",
+      condition: String,    // 计算结果为 bool 的算术表达式
+      true: T,              // 当 condition = true 时使用的值
+      false: T              // 当 condition = false 时使用的值
+  }
+  ```
+  条件使用 [fasteval](https://crates.io/crates/fasteval) 库求值；表达式中没有可用变量。
+
+  _示例：_
+  ```json5
+  { type: "if", condition: "2 > 1", true: [1,2,3], false: [4,5,6] }
+  // 得到 [1,2,3]，因为 2 > 1 求值为 true
+  ```
+
+- **`time`** — 生成两个时间字符串（开始和结束）的列表。当前直接返回提供的开始和结束字符串；interval 和 format 会被解析但尚未用于生成。
+
+  _参数：_
+  ```json5
+  {
+      type: "time",
+      start: String,        // 开始时间字符串
+      end: String,          // 结束时间字符串
+      interval: String,     // 时间间隔（当前未使用）
+      format?: String       // 可选的时间格式（当前未使用）
+  }
+  ```
+  _示例：_
+  ```json5
+  { type: "time", start: "2026-01-01", end: "2026-01-02", interval: "1d" }
+  // 得到 ["2026-01-01", "2026-01-02"]
+  ```
+
 #### 使用映射
 
 映射条目在其他地方通过前缀 `map.` 引用。例如，如果映射包含键 `myrange`，您可以在任何接受 `DataPack<T>` 的字段（大多数数组和数字字段）中使用 `"map.myrange"`。
@@ -452,6 +493,7 @@ config: {
     // 确定 plotly 标志是否显示在模式栏的末尾
     display_logo?: bool,
     // 使用公司标志对图像进行水印处理
+    watermark?: bool,
 }
 ```
 

docs/USAGE-zh_CN.md

@@ -188,7 +188,11 @@ The following notation is used throughout this reference to describe expected ty
 
 - **Rgb** – `"rgb(u8, u8, u8)"` (e.g., `"rgb(0, 0, 0)"`)
 - **Rgba** – `"rgba(u8, u8, u8, f64)"` (e.g., `"rgba(0, 0, 0, 0.0)"`)
-- **Color** – either a named CSS color (`{ named_color: "aliceblue" }`), an RGB string, or an RGBA string.
+- **Color** – can be one of the following:
+  - A named CSS color: `{ named_color: "aliceblue" }`
+  - An RGB color: `{ rgb_color: "rgb(255, 0, 0)" }`
+  - An RGBA color: `{ rgba_color: "rgba(255, 0, 0, 0.5)" }`
+  - Alternatively, for RGB and RGBA, you can use the plain string forms `"rgb(255,0,0)"` or `"rgba(255,0,0,0.5)"` directly.
 
 ### Map and Generators
 
@@ -300,6 +304,43 @@ All generator objects must have a `type` field. The following generator types ar
   // yields [0.0, 0.25, 0.5, 0.75, 1.0]
   ```
 
+- **`if`** — Conditionally selects between two values based on an arithmetic expression.
+
+  _Parameters:_
+  ```json5
+  {
+      type: "if",
+      condition: String,    // arithmetic expression that evaluates to a number
+      true: T,              // value used when condition ≠ 0.0
+      false: T              // value used when condition = 0.0
+  }
+  ```
+  The condition is evaluated using the [fasteval](https://crates.io/crates/fasteval) library; no variables are available.
+
+  _Example:_
+  ```json5
+  { type: "if", condition: "2 > 1", true: [1,2,3], false: [4,5,6] }
+  // yields [1,2,3] because 2 > 1 evaluates to 1.0 (non‑zero)
+  ```
+
+- **`time`** — Generates a list of two time strings (start and end). Currently returns the provided start and end strings directly; interval and format are parsed but not yet used for generation.
+
+  _Parameters:_
+  ```json5
+  {
+      type: "time",
+      start: String,        // start time string
+      end: String,          // end time string
+      interval: String,     // time interval (currently unused)
+      format?: String       // optional time format (currently unused)
+  }
+  ```
+  _Example:_
+  ```json5
+  { type: "time", start: "2026-01-01", end: "2026-01-02", interval: "1d" }
+  // yields ["2026-01-01", "2026-01-02"]
+  ```
+
 #### Using the Map
 
 Map entries are referenced elsewhere by prefixing the key with `map.`. For example, if the map contains a key `myrange`, you can refer to it as `"map.myrange"` in any field that accepts a `DataPack<T>` (most array and numeric fields).

docs/USAGE.md

@@ -32,13 +32,15 @@ macro_rules! translate {
         let target = $target;
         $(
             let target = if let Some(v) = $value.get_mut(stringify!($method)) {
-                let data = serde_json::from_value::<DataPack<$ty>>(v.take())?;
-                target.$method(data.unwrap($map)?)
+                let data = serde_json::from_value::<DataPack<$ty>>(v.take())
+                    .map_err(|e| ::anyhow::anyhow!("Failed to deserialize field '{}': {}", stringify!($method), e))?;
+                target.$method(data.unwrap($map)
+                    .map_err(|e| ::anyhow::anyhow!("Failed to unwrap DataPack for field '{}': {}", stringify!($method), e))?)
             } else {
                 target
             };
         )*
-        Ok::<_, serde_json::Error>(target)
+        Ok::<_, ::anyhow::Error>(target)
     }};
 }
 
@@ -53,8 +55,10 @@ macro_rules! translate_enum {
         let target = $target;
         $(
             let target = if let Some(v) = $value.get_mut(stringify!($method)) {
-                let data = serde_json::from_value::<DataPack<String>>(v.take())?;
-                let s = data.unwrap($map)?;
+                let data = serde_json::from_value::<DataPack<String>>(v.take())
+                    .map_err(|e| ::anyhow::anyhow!("Failed to deserialize field '{}': {}", stringify!($method), e))?;
+                let s = data.unwrap($map)
+                    .map_err(|e| ::anyhow::anyhow!("Failed to unwrap DataPack for field '{}': {}", stringify!($method), e))?;
                 match s.as_str() {
                     $($str_val => target.$method($variant),)*
                     unexpected => {

src/macros.rs

@@ -1,4 +1,4 @@
-use anyhow::{Result, anyhow, Context};
+use anyhow::{Context, Result, anyhow};
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de::DeserializeOwned};
 use serde_json::{Map as JsonMap, Value, value::Index};
 use std::fmt::{Debug, Display};
@@ -60,14 +60,22 @@ where
                     let data = ez_eval(&expr, &mut namespace)?;
                     result.push(Value::from(data));
                 }
-                serde_json::from_value(result.into())
-                    .with_context(|| format!("failed to deserialize generated list for type '{}'", value_type))
+                serde_json::from_value(result.into()).with_context(|| {
+                    format!(
+                        "failed to deserialize generated list for type '{}'",
+                        value_type
+                    )
+                })
             }
             "g-number" => {
                 let expr: String = must_translate(&mut value, map, "expr")?;
                 let data = ez_eval(&expr, &mut fasteval::EmptyNamespace {})?;
-                serde_json::from_value(data.into())
-                    .with_context(|| format!("failed to deserialize generated number for type '{}'", value_type))
+                serde_json::from_value(data.into()).with_context(|| {
+                    format!(
+                        "failed to deserialize generated number for type '{}'",
+                        value_type
+                    )
+                })
             }
             "g-range" => {
                 let begin: f64 = must_translate(&mut value, map, "begin")?;
@@ -86,15 +94,23 @@ where
                     result.push(Value::from(current));
                     current += step;
                 }
-                serde_json::from_value(result.into())
-                    .with_context(|| format!("failed to deserialize generated range for type '{}'", value_type))
+                serde_json::from_value(result.into()).with_context(|| {
+                    format!(
+                        "failed to deserialize generated range for type '{}'",
+                        value_type
+                    )
+                })
             }
             "g-repeat" => {
                 let val: Value = must_translate(&mut value, map, "value")?;
                 let count: u64 = must_translate(&mut value, map, "count")?;
                 let result = std::iter::repeat_n(val, count as usize).collect::<Vec<_>>();
-                serde_json::from_value(result.into())
-                    .with_context(|| format!("failed to deserialize repeated values for type '{}'", value_type))
+                serde_json::from_value(result.into()).with_context(|| {
+                    format!(
+                        "failed to deserialize repeated values for type '{}'",
+                        value_type
+                    )
+                })
             }
             "g-linear" => {
                 let begin: f64 = must_translate(&mut value, map, "begin")?;
@@ -113,8 +129,54 @@ where
                         result.push(Value::from(val));
                     }
                 }
-                serde_json::from_value(result.into())
-                    .with_context(|| format!("failed to deserialize linear spaced values for type '{}'", value_type))
+                serde_json::from_value(result.into()).with_context(|| {
+                    format!(
+                        "failed to deserialize linear spaced values for type '{}'",
+                        value_type
+                    )
+                })
+            }
+            "if" => {
+                let condition: String = must_translate(&mut value, map, "condition")?;
+                let true_val: Value = must_translate(&mut value, map, "true")?;
+                let false_val: Value = must_translate(&mut value, map, "false")?;
+
+                // Evaluate condition using fasteval
+                let mut namespace = fasteval::StrToF64Namespace::new();
+                // We need to check if the condition contains 'i' variable
+                // For simplicity, assume it's a boolean expression that evaluates to non-zero for true
+                let result = ez_eval(&condition, &mut namespace)?;
+                let selected = if result != 0.0 { true_val } else { false_val };
+
+                // Parse the selected value according to its type
+                if !selected.is_object() {
+                    serde_json::from_value::<T>(selected.clone())
+                        .with_context(|| "failed to deserialize non-object if result")
+                } else {
+                    // If it's an object, it might be another generator
+                    Self::parse_map(map, selected)
+                }
+            }
+            "time" => {
+                // Simple time generator: produce timestamps as strings
+                let start: String = must_translate(&mut value, map, "start")?;
+                let end: String = must_translate(&mut value, map, "end")?;
+                let _interval: String = must_translate(&mut value, map, "interval")?;
+                let _format: Option<String> = if value.get("format").is_some() {
+                    Some(must_translate(&mut value, map, "format")?)
+                } else {
+                    None
+                };
+
+                // For now, just return the start and end as strings
+                // In a real implementation, you'd parse dates and generate a series
+                let result = vec![Value::from(start.clone()), Value::from(end.clone())];
+                serde_json::from_value(result.into()).with_context(|| {
+                    format!(
+                        "failed to deserialize time values for type '{}'",
+                        value_type
+                    )
+                })
             }
             _ => Err(anyhow!("unknown type `{}`", value_type)),
         }