use crate::LexicalError;
use crate::json::{Object, Value};
use crate::node::LexicalNode;
use std::any::TypeId;
use std::cell::RefCell;
use std::collections::HashMap;
use std::fmt;
use std::rc::Rc;
pub type SchemaParse = Rc<dyn Fn(&Value) -> Value>;
pub type SchemaIsEqual = Rc<dyn Fn(&Value, &Value) -> bool>;
pub type SchemaAccepts = Rc<dyn Fn(&Value) -> bool>;
#[derive(Clone)]
pub enum SerializationSchemaMeta {
String,
Number {
min: Option<f64>,
max: Option<f64>,
integer: bool,
clamp: bool,
},
Boolean,
Enum {
values: Vec<Value>,
},
Array {
item: SerializationSchema,
},
Set {
item: SerializationSchema,
},
Nullable {
inner: SerializationSchema,
default_as_null: bool,
},
Optional {
inner: SerializationSchema,
omit_default: bool,
},
Union {
members: Vec<SerializationSchema>,
},
Raw,
Object {
fields: Vec<(String, SerializationSchema)>,
},
Aliased {
inner: SerializationSchema,
aliases: Vec<(String, Value)>,
},
Transform {
inner: SerializationSchema,
},
}
impl SerializationSchemaMeta {
pub fn kind(&self) -> &'static str {
match self {
Self::String => "string",
Self::Number { .. } => "number",
Self::Boolean => "boolean",
Self::Enum { .. } => "enum",
Self::Array { .. } => "array",
Self::Set { .. } => "set",
Self::Nullable { .. } => "nullable",
Self::Optional { .. } => "optional",
Self::Union { .. } => "union",
Self::Raw => "raw",
Self::Object { .. } => "object",
Self::Aliased { .. } => "aliased",
Self::Transform { .. } => "transform",
}
}
}
struct SchemaInner {
meta: SerializationSchemaMeta,
default_value: Value,
is_equal: Option<SchemaIsEqual>,
accepts: Option<SchemaAccepts>,
accepts_is_derived: bool,
is_catch_all: bool,
parse: SchemaParse,
}
#[derive(Clone)]
pub struct SerializationSchema(Rc<SchemaInner>);
impl fmt::Debug for SerializationSchema {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"SerializationSchema({}, default {})",
self.0.meta.kind(),
self.0.default_value
)
}
}
impl SerializationSchema {
pub fn new(
meta: SerializationSchemaMeta,
default_value: Value,
is_equal: Option<SchemaIsEqual>,
accepts: Option<SchemaAccepts>,
parse: impl Fn(&Value) -> Value + 'static,
) -> Self {
let declared = accepts.is_some();
Self::build(
Rc::new(parse),
meta,
Some(default_value),
is_equal,
accepts,
!declared,
)
}
fn make(
parse: impl Fn(&Value) -> Value + 'static,
meta: SerializationSchemaMeta,
default_value: Option<Value>,
is_equal: Option<SchemaIsEqual>,
accepts: impl Fn(&Value) -> bool + 'static,
) -> Self {
Self::build(
Rc::new(parse),
meta,
default_value,
is_equal,
Some(Rc::new(accepts)),
true,
)
}
fn build(
parse: SchemaParse,
meta: SerializationSchemaMeta,
default_value: Option<Value>,
is_equal: Option<SchemaIsEqual>,
accepts: Option<SchemaAccepts>,
accepts_is_derived: bool,
) -> Self {
let default_value = match default_value {
None | Some(Value::Undefined) => parse(&Value::Undefined),
Some(value) => value,
};
let declared = accepts.is_some() && !accepts_is_derived;
let is_catch_all = !declared && compute_is_catch_all(&meta);
SerializationSchema(Rc::new(SchemaInner {
meta,
default_value,
is_equal,
accepts,
accepts_is_derived,
is_catch_all,
parse,
}))
}
pub fn parse(&self, value: &Value) -> Value {
(self.0.parse)(value)
}
pub fn default_value(&self) -> &Value {
&self.0.default_value
}
pub fn meta(&self) -> &SerializationSchemaMeta {
&self.0.meta
}
pub fn is_equal(&self) -> Option<&SchemaIsEqual> {
self.0.is_equal.as_ref()
}
pub fn accepts(&self) -> Option<&SchemaAccepts> {
self.0.accepts.as_ref()
}
pub fn declared_accepts(&self) -> Option<&SchemaAccepts> {
if self.0.accepts_is_derived {
None
} else {
self.0.accepts.as_ref()
}
}
pub fn is(&self, other: &SerializationSchema) -> bool {
Rc::ptr_eq(&self.0, &other.0)
}
fn is_set(&self) -> bool {
matches!(self.0.meta, SerializationSchemaMeta::Set { .. })
}
}
pub fn is_schema_equal(schema: &SerializationSchema, a: &Value, b: &Value) -> bool {
a == b || schema.0.is_equal.as_ref().is_some_and(|eq| eq(a, b))
}
pub fn is_schema_default(schema: &SerializationSchema, value: &Value) -> bool {
is_schema_equal(schema, value, &schema.0.default_value)
}
fn accepts_value(schema: &SerializationSchema, value: &Value) -> bool {
match &schema.0.accepts {
Some(accepts) => accepts(value),
None => schema_match(schema, value).is_some(),
}
}
fn schema_match(schema: &SerializationSchema, value: &Value) -> Option<Value> {
if schema.0.accepts.is_some() {
return accepts_value(schema, value).then(|| schema.parse(value));
}
let parsed = schema.parse(value);
(!is_schema_default(schema, &parsed) || *value == schema.0.default_value).then_some(parsed)
}
fn compute_is_catch_all(meta: &SerializationSchemaMeta) -> bool {
use SerializationSchemaMeta as M;
match meta {
M::Raw => true,
M::Union { members } => !members.is_empty() && members.iter().all(|m| m.0.is_catch_all),
M::Nullable { inner, .. }
| M::Optional { inner, .. }
| M::Transform { inner }
| M::Aliased { inner, .. } => inner.0.is_catch_all,
_ => false,
}
}
const FIT_WHOLE: u8 = 1;
const FIT_VIA_CATCH_ALL: u8 = 2;
const FIT_COERCIBLE: u8 = 3;
const FIT_NONE: u8 = 4;
fn fit_of(schema: &SerializationSchema, value: &Value) -> u8 {
let declared = schema.declared_accepts();
let narrowed = declared.is_some();
if let Some(declared) = declared
&& !declared(value)
{
return FIT_NONE;
}
let fit = meta_fit_of(schema, value, narrowed);
if narrowed && fit == FIT_NONE {
FIT_COERCIBLE
} else {
fit
}
}
fn meta_fit_of(schema: &SerializationSchema, value: &Value, narrowed: bool) -> u8 {
use SerializationSchemaMeta as M;
match &schema.0.meta {
M::Raw => {
if narrowed {
FIT_WHOLE
} else {
FIT_VIA_CATCH_ALL
}
}
M::Array { item } => {
let Value::Array(items) = value else {
return FIT_NONE;
};
let mut worst = FIT_WHOLE;
for element in items.iter().filter(|v| !v.is_undefined()) {
worst = worst.max(fit_of(item, element));
}
worst.min(FIT_COERCIBLE)
}
M::Object { fields } => {
let Some(source) = as_plain_object(value) else {
return FIT_NONE;
};
if !narrowed && has_undeclared_key(source, fields) {
return FIT_NONE;
}
let mut worst = FIT_WHOLE;
for (key, v) in source.iter() {
if let Some((_, field)) = fields.iter().find(|(k, _)| k == key) {
worst = worst.max(fit_of(field, v));
}
}
worst.min(FIT_COERCIBLE)
}
M::Union { members } => best_union_member(members, value).0,
M::Aliased { inner, aliases } => {
let owned = value
.as_str()
.is_some_and(|s| aliases.iter().any(|(k, _)| k == s));
if owned {
FIT_WHOLE
} else {
fit_of(inner, value)
}
}
M::Nullable { inner, .. } => {
if value.is_undefined() || value.is_null() {
FIT_WHOLE
} else {
fit_of(inner, value)
}
}
M::Optional { inner, .. } => {
if value.is_undefined() {
FIT_WHOLE
} else {
fit_of(inner, value)
}
}
M::Transform { inner } => fit_of(inner, value),
_ => {
if narrowed || accepts_value(schema, value) {
FIT_WHOLE
} else {
FIT_NONE
}
}
}
}
fn best_union_member<'a>(
members: &'a [SerializationSchema],
value: &Value,
) -> (u8, Option<&'a SerializationSchema>) {
let mut member = None;
let mut best_rank = FIT_NONE;
let mut best_fit = FIT_NONE;
for candidate in members {
let fit = fit_of(candidate, value);
let rank = if fit < FIT_COERCIBLE && candidate.0.is_catch_all {
FIT_COERCIBLE
} else {
fit
};
if rank < best_rank {
member = Some(candidate);
best_rank = rank;
best_fit = fit;
if rank == FIT_WHOLE {
break;
}
}
}
(best_fit, member)
}
fn undeclared(combinator: &str, inner: &SerializationSchema) -> Result<(), LexicalError> {
not_nested_set(combinator, inner)
}
fn not_nested_set(combinator: &str, inner: &SerializationSchema) -> Result<(), LexicalError> {
if inner.is_set() {
return Err(LexicalError::new(format!(
"{combinator}: arraySetValue can only be the whole value of a createState, not part of another schema or a node property"
)));
}
Ok(())
}
fn as_plain_object(value: &Value) -> Option<&Object> {
value.as_object()
}
fn has_undeclared_key(source: &Object, fields: &[(String, SerializationSchema)]) -> bool {
source
.keys()
.any(|key| !fields.iter().any(|(k, _)| k == key))
}
pub fn string_value(default_value: &str) -> SerializationSchema {
let default_value = default_value.to_owned();
SerializationSchema::make(
move |value| match value {
Value::String(_) => value.clone(),
_ => Value::String(default_value.clone()),
},
SerializationSchemaMeta::String,
None,
None,
|value| matches!(value, Value::String(_)),
)
}
#[derive(Clone, Copy, Debug, Default)]
pub struct NumberValueOptions {
pub min: Option<f64>,
pub max: Option<f64>,
pub integer: bool,
pub clamp: bool,
}
pub(crate) fn is_json_number(s: &str) -> bool {
let b = s.as_bytes();
let mut i = 0;
let digits = |i: &mut usize| {
let start = *i;
while *i < b.len() && b[*i].is_ascii_digit() {
*i += 1;
}
*i - start
};
if b.get(i) == Some(&b'-') {
i += 1;
}
match b.get(i) {
Some(b'0') => i += 1,
Some(b'1'..=b'9') => {
digits(&mut i);
}
_ => return false,
}
if b.get(i) == Some(&b'.') {
i += 1;
if digits(&mut i) == 0 {
return false;
}
}
if let Some(b'e' | b'E') = b.get(i) {
i += 1;
if let Some(b'+' | b'-') = b.get(i) {
i += 1;
}
if digits(&mut i) == 0 {
return false;
}
}
i == b.len()
}
fn js_number_string(n: f64) -> String {
crate::json::number_to_string(n)
}
pub fn number_value(
default_value: f64,
options: NumberValueOptions,
) -> Result<SerializationSchema, LexicalError> {
let NumberValueOptions {
min,
max,
integer,
clamp,
} = options;
let lower = if integer { min.map(f64::ceil) } else { min };
let upper = if integer { max.map(f64::floor) } else { max };
if let (Some(lo), Some(hi)) = (lower, upper)
&& lo > hi
{
let rounded = if integer && (lower != min || upper != max) {
format!(
" (rounded inward from {}..{} because the domain is integers)",
min.map_or("undefined".to_owned(), js_number_string),
max.map_or("undefined".to_owned(), js_number_string),
)
} else {
String::new()
};
return Err(LexicalError::new(format!(
"numberValue: the domain is empty; min {} is above max {}{rounded}",
js_number_string(lo),
js_number_string(hi),
)));
}
let coerce = |value: &Value| -> Option<f64> {
match value {
Value::Number(n) => Some(*n),
Value::String(s) if is_json_number(s) => Some(s.parse().expect("a JSON number")),
_ => None,
}
};
let is_numeric = move |n: f64| n.is_finite() && (!integer || n.fract() == 0.0);
let in_domain = move |n: f64| {
is_numeric(n) && lower.is_none_or(|lo| n >= lo) && upper.is_none_or(|hi| n <= hi)
};
Ok(SerializationSchema::make(
move |value| {
let parsed = coerce(value);
if clamp && let Some(n) = parsed.filter(|n| is_numeric(*n)) {
return Value::Number(match (lower, upper) {
(Some(lo), _) if n < lo => lo,
(_, Some(hi)) if n > hi => hi,
_ => n,
});
}
Value::Number(parsed.filter(|n| in_domain(*n)).unwrap_or(default_value))
},
SerializationSchemaMeta::Number {
min: lower,
max: upper,
integer,
clamp,
},
None,
None,
move |value| {
coerce(value).is_some_and(|n| if clamp { is_numeric(n) } else { in_domain(n) })
},
))
}
pub fn boolean_value(default_value: bool) -> SerializationSchema {
SerializationSchema::make(
move |value| match value {
Value::Bool(_) => value.clone(),
_ => Value::Bool(default_value),
},
SerializationSchemaMeta::Boolean,
None,
None,
|value| matches!(value, Value::Bool(_)),
)
}
fn same_value_zero(a: &Value, b: &Value) -> bool {
match (a, b) {
(Value::Number(x), Value::Number(y)) if x.is_nan() && y.is_nan() => true,
_ => a == b,
}
}
pub fn enum_value(
values: Vec<Value>,
default_value: Option<Value>,
) -> Result<SerializationSchema, LexicalError> {
if values.is_empty() {
return Err(LexicalError::new(
"enumValue: values must not be empty; an enum with no members admits no value",
));
}
let fallback = default_value.unwrap_or_else(|| values[0].clone());
let allowed = {
let values = values.clone();
move |value: &Value| values.iter().any(|m| same_value_zero(m, value))
};
if !allowed(&fallback) {
return Err(LexicalError::new(
"enumValue: the default value is not one of the values",
));
}
let parse_allowed = allowed.clone();
let parse_fallback = fallback.clone();
let fallback_undefined = fallback.is_undefined();
Ok(SerializationSchema::make(
move |value| {
if !value.is_undefined() && parse_allowed(value) {
value.clone()
} else {
parse_fallback.clone()
}
},
SerializationSchemaMeta::Enum { values },
Some(fallback),
None,
move |value| allowed(value) && (!value.is_undefined() || fallback_undefined),
))
}
fn lift_is_equal(inner: &SerializationSchema) -> Option<SchemaIsEqual> {
let is_equal = inner.0.is_equal.clone()?;
let nil = |v: &Value| v.is_undefined() || v.is_null();
Some(Rc::new(move |a, b| {
if nil(a) || nil(b) {
a == b
} else {
is_equal(a, b)
}
}))
}
pub fn nullable(
inner: SerializationSchema,
default_as_null: bool,
) -> Result<SerializationSchema, LexicalError> {
undeclared("nullable", &inner)?;
let parse_inner = inner.clone();
let accepts_inner = inner.clone();
let is_equal = lift_is_equal(&inner);
Ok(SerializationSchema::make(
move |value| {
if value.is_undefined() || value.is_null() {
return Value::Null;
}
let parsed = parse_inner.parse(value);
if default_as_null && is_schema_default(&parse_inner, &parsed) {
Value::Null
} else {
parsed
}
},
SerializationSchemaMeta::Nullable {
inner,
default_as_null,
},
None,
is_equal,
move |value| {
value.is_undefined() || value.is_null() || accepts_value(&accepts_inner, value)
},
))
}
pub fn optional(
inner: SerializationSchema,
omit_default: bool,
) -> Result<SerializationSchema, LexicalError> {
undeclared("optional", &inner)?;
let parse_inner = inner.clone();
let accepts_inner = inner.clone();
let is_equal = lift_is_equal(&inner);
Ok(SerializationSchema::make(
move |value| {
if value.is_undefined() {
return Value::Undefined;
}
let parsed = parse_inner.parse(value);
if omit_default && is_schema_default(&parse_inner, &parsed) {
Value::Undefined
} else {
parsed
}
},
SerializationSchemaMeta::Optional {
inner,
omit_default,
},
None,
is_equal,
move |value| value.is_undefined() || accepts_value(&accepts_inner, value),
))
}
pub fn union_value(
members: Vec<SerializationSchema>,
default_value: Option<Value>,
) -> Result<SerializationSchema, LexicalError> {
if members.is_empty() {
return Err(LexicalError::new(
"unionValue: at least one member schema is required",
));
}
for member in &members {
undeclared("unionValue", member)?;
}
let fallback = default_value.unwrap_or_else(|| members[0].0.default_value.clone());
let parse_members = members.clone();
let accepts_members = members.clone();
let parse_fallback = fallback.clone();
let fallback_undefined = fallback.is_undefined();
Ok(SerializationSchema::make(
move |value| {
if value.is_undefined() {
return parse_fallback.clone();
}
match best_union_member(&parse_members, value).1 {
Some(member) => member.parse(value),
None => parse_fallback.clone(),
}
},
SerializationSchemaMeta::Union { members },
Some(fallback),
Some(Rc::new(|a: &Value, b: &Value| a == b)),
move |value| {
(!value.is_undefined() || fallback_undefined)
&& accepts_members.iter().any(|m| accepts_value(m, value))
},
))
}
pub fn aliased_value(
inner: SerializationSchema,
aliases: Vec<(String, Value)>,
) -> Result<SerializationSchema, LexicalError> {
undeclared("aliasedValue", &inner)?;
let alias = |aliases: &[(String, Value)], value: &Value| -> Option<Value> {
let s = value.as_str()?;
aliases.iter().find(|(k, _)| k == s).map(|(_, v)| v.clone())
};
let parse_inner = inner.clone();
let parse_aliases = aliases.clone();
let accepts_inner = inner.clone();
let accepts_aliases = aliases.clone();
let default_value = inner.0.default_value.clone();
let is_equal = inner.0.is_equal.clone();
Ok(SerializationSchema::make(
move |value| alias(&parse_aliases, value).unwrap_or_else(|| parse_inner.parse(value)),
SerializationSchemaMeta::Aliased { inner, aliases },
Some(default_value),
is_equal,
move |value| {
alias(&accepts_aliases, value).is_some() || accepts_value(&accepts_inner, value)
},
))
}
pub fn transform_value(
inner: SerializationSchema,
transform: impl Fn(Value) -> Value + 'static,
is_equal: Option<SchemaIsEqual>,
) -> Result<SerializationSchema, LexicalError> {
undeclared("transformValue", &inner)?;
let transform = Rc::new(transform);
let default_value = transform(inner.0.default_value.clone());
if is_equal.is_some() && !matches!(default_value, Value::Array(_) | Value::Object(_)) {
return Err(LexicalError::new(format!(
"transformValue: isEqual compares reference-typed values, but this schema parses to {}. Two primitives that are not === are two different serialized values; declaring them equal loses one of them in the compact form.",
js_typeof(&default_value)
)));
}
let parse_inner = inner.clone();
let accepts_inner = inner.clone();
let parse_transform = transform.clone();
Ok(SerializationSchema::make(
move |value| parse_transform(parse_inner.parse(value)),
SerializationSchemaMeta::Transform { inner },
Some(default_value),
is_equal,
move |value| accepts_value(&accepts_inner, value),
))
}
fn js_typeof(value: &Value) -> &'static str {
match value {
Value::Undefined => "undefined",
Value::Null | Value::Array(_) | Value::Object(_) => "object",
Value::Bool(_) => "boolean",
Value::Number(_) => "number",
Value::String(_) => "string",
}
}
pub fn raw_value() -> SerializationSchema {
SerializationSchema::make(
Value::clone,
SerializationSchemaMeta::Raw,
None,
None,
|_| true,
)
}
pub fn array_value(item: SerializationSchema) -> Result<SerializationSchema, LexicalError> {
undeclared("arrayValue", &item)?;
let parse_item = item.clone();
let equal_item = item.clone();
Ok(SerializationSchema::make(
move |value| match value {
Value::Array(items) => {
Value::Array(items.iter().map(|v| parse_item.parse(v)).collect())
}
_ => Value::Array(Vec::new()),
},
SerializationSchemaMeta::Array { item },
None,
Some(Rc::new(move |a: &Value, b: &Value| match (a, b) {
(Value::Array(a), Value::Array(b)) => {
a.len() == b.len()
&& a.iter()
.zip(b)
.all(|(x, y)| is_schema_equal(&equal_item, x, y))
}
_ => false,
})),
|value| matches!(value, Value::Array(_)),
))
}
fn js_cmp(a: &str, b: &str) -> std::cmp::Ordering {
a.encode_utf16().cmp(b.encode_utf16())
}
pub fn array_set_value(item: SerializationSchema) -> Result<SerializationSchema, LexicalError> {
undeclared("arraySetValue", &item)?;
if !matches!(item.0.default_value, Value::String(_)) {
return Err(LexicalError::new(
"arraySetValue: the item schema must produce strings",
));
}
let parse_item = item.clone();
Ok(SerializationSchema::make(
move |value| {
let Value::Array(items) = value else {
return Value::Array(Vec::new());
};
let mut members: Vec<String> = items
.iter()
.filter(|m| !m.is_undefined() && accepts_value(&parse_item, m))
.filter_map(|m| match parse_item.parse(m) {
Value::String(s) => Some(s),
_ => None,
})
.collect();
members.sort_by(|a, b| js_cmp(a, b));
members.dedup();
Value::Array(members.into_iter().map(Value::String).collect())
},
SerializationSchemaMeta::Set { item },
None,
Some(Rc::new(|a: &Value, b: &Value| a == b)),
|value| matches!(value, Value::Array(_)),
))
}
const OBJECT_PROTOTYPE_MEMBERS: [&str; 12] = [
"__defineGetter__",
"__defineSetter__",
"__lookupGetter__",
"__lookupSetter__",
"__proto__",
"constructor",
"hasOwnProperty",
"isPrototypeOf",
"propertyIsEnumerable",
"toLocaleString",
"toString",
"valueOf",
];
fn check_field_names<'a>(
combinator: &str,
fields: impl IntoIterator<Item = (&'a str, &'a SerializationSchema)>,
) -> Result<(), LexicalError> {
for (key, schema) in fields {
if key == "__proto__" {
return Err(LexicalError::new(format!(
"{combinator}: \"__proto__\" is not a valid field name"
)));
}
if OBJECT_PROTOTYPE_MEMBERS.contains(&key) {
return Err(LexicalError::new(format!(
"{combinator}: \"{key}\" is a member of Object.prototype, which a serialized object inherits, so it cannot be told apart from a property the document never carried"
)));
}
not_nested_set(combinator, schema)?;
}
Ok(())
}
fn js_property(value: &Value, key: &str) -> Value {
match value {
Value::Object(object) => object.get(key).cloned().unwrap_or(Value::Undefined),
Value::Array(items) => {
if key == "length" {
return Value::Number(items.len() as f64);
}
crate::json::array_index(key)
.and_then(|i| items.get(i as usize))
.cloned()
.unwrap_or(Value::Undefined)
}
_ => Value::Undefined,
}
}
pub fn object_value(
fields: Vec<(&str, SerializationSchema)>,
) -> Result<SerializationSchema, LexicalError> {
let fields: Vec<(String, SerializationSchema)> =
fields.into_iter().map(|(k, s)| (k.to_owned(), s)).collect();
check_field_names("objectValue", fields.iter().map(|(k, s)| (k.as_str(), s)))?;
let parse_fields = fields.clone();
let equal_fields = fields.clone();
let accepts_fields = fields.clone();
Ok(SerializationSchema::make(
move |value| {
let mut result = Object::new();
for (key, schema) in &parse_fields {
result.insert(key.as_str(), schema.parse(&js_property(value, key)));
}
Value::Object(result)
},
SerializationSchemaMeta::Object { fields },
None,
Some(Rc::new(move |a: &Value, b: &Value| {
let (Some(a), Some(b)) = (as_plain_object(a), as_plain_object(b)) else {
return false;
};
!has_undeclared_key(a, &equal_fields)
&& !has_undeclared_key(b, &equal_fields)
&& equal_fields.iter().all(|(key, schema)| {
is_schema_equal(
schema,
a.get(key).unwrap_or(&Value::Undefined),
b.get(key).unwrap_or(&Value::Undefined),
)
})
})),
move |value| {
as_plain_object(value).is_some_and(|o| !has_undeclared_key(o, &accepts_fields))
},
))
}
pub trait SchemaValue: Sized {
fn to_schema_value(&self) -> Value;
fn from_schema_value(value: &Value) -> Option<Self>;
}
impl SchemaValue for String {
fn to_schema_value(&self) -> Value {
Value::String(self.clone())
}
fn from_schema_value(value: &Value) -> Option<Self> {
value.as_str().map(str::to_owned)
}
}
impl SchemaValue for f64 {
fn to_schema_value(&self) -> Value {
Value::Number(*self)
}
fn from_schema_value(value: &Value) -> Option<Self> {
value.as_f64()
}
}
impl SchemaValue for bool {
fn to_schema_value(&self) -> Value {
Value::Bool(*self)
}
fn from_schema_value(value: &Value) -> Option<Self> {
value.as_bool()
}
}
impl SchemaValue for Value {
fn to_schema_value(&self) -> Value {
self.clone()
}
fn from_schema_value(value: &Value) -> Option<Self> {
Some(value.clone())
}
}
impl<T: SchemaValue> SchemaValue for Option<T> {
fn to_schema_value(&self) -> Value {
self.as_ref().map_or(Value::Undefined, T::to_schema_value)
}
fn from_schema_value(value: &Value) -> Option<Self> {
if value.is_undefined() || value.is_null() {
Some(None)
} else {
T::from_schema_value(value).map(Some)
}
}
}
impl<T: SchemaValue> SchemaValue for Vec<T> {
fn to_schema_value(&self) -> Value {
Value::Array(self.iter().map(T::to_schema_value).collect())
}
fn from_schema_value(value: &Value) -> Option<Self> {
value.as_array()?.iter().map(T::from_schema_value).collect()
}
}
pub type SchemaGetter = Rc<dyn Fn(&dyn LexicalNode) -> Value>;
pub type SchemaSetter = Rc<dyn Fn(&mut dyn LexicalNode, Value)>;
pub type SchemaPredicate = Rc<dyn Fn(&dyn LexicalNode) -> bool>;
#[derive(Clone)]
pub struct SchemaField {
schema: SerializationSchema,
getter: Option<SchemaGetter>,
when: Option<SchemaPredicate>,
setter: Option<SchemaSetter>,
derived: bool,
}
impl fmt::Debug for SchemaField {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SchemaField")
.field("schema", &self.schema)
.field("getter", &self.getter.is_some())
.field("when", &self.when.is_some())
.field("setter", &self.setter.is_some())
.field("derived", &self.derived)
.finish()
}
}
impl SchemaField {
pub fn schema(&self) -> &SerializationSchema {
&self.schema
}
pub fn is_derived(&self) -> bool {
self.derived
}
pub fn is_exported(&self) -> bool {
self.getter.is_some()
}
pub fn is_imported(&self) -> bool {
self.setter.is_some()
}
pub fn when(mut self, when: impl Fn(&dyn LexicalNode) -> bool + 'static) -> Self {
self.when = Some(Rc::new(when));
self
}
pub fn derived(mut self) -> Self {
self.derived = true;
self
}
fn is_compact_default(&self, value: &Value) -> bool {
value.is_undefined() || is_schema_default(&self.schema, value)
}
}
fn node_as<N: LexicalNode>(node: &dyn LexicalNode) -> &N {
node.downcast_ref::<N>()
.expect("a schema field of the node's own class")
}
fn node_as_mut<N: LexicalNode>(node: &mut dyn LexicalNode) -> &mut N {
node.downcast_mut::<N>()
.expect("a schema field of the node's own class")
}
pub fn schema_getter<N: LexicalNode>(get: impl Fn(&N) -> Value + 'static) -> SchemaGetter {
Rc::new(move |node| get(node_as::<N>(node)))
}
pub fn schema_setter<N: LexicalNode>(set: impl Fn(&mut N, Value) + 'static) -> SchemaSetter {
Rc::new(move |node, value| set(node_as_mut::<N>(node), value))
}
pub fn with_field<N: LexicalNode, V: SchemaValue + 'static>(
schema: SerializationSchema,
field: fn(&N) -> &V,
field_mut: fn(&mut N) -> &mut V,
) -> Result<SchemaField, LexicalError> {
not_nested_set("withField", &schema)?;
let optional = matches!(schema.meta(), SerializationSchemaMeta::Optional { .. });
Ok(SchemaField {
schema,
getter: Some(schema_getter::<N>(move |node| {
match field(node).to_schema_value() {
Value::Undefined if !optional => Value::Null,
value => value,
}
})),
when: None,
setter: Some(schema_setter::<N>(move |node, value| {
if let Some(value) = V::from_schema_value(&value) {
*field_mut(node) = value;
}
})),
derived: false,
})
}
pub fn with_accessors(
schema: SerializationSchema,
getter: Option<SchemaGetter>,
setter: Option<SchemaSetter>,
) -> Result<SchemaField, LexicalError> {
not_nested_set("withAccessors", &schema)?;
Ok(SchemaField {
schema,
getter,
when: None,
setter,
derived: false,
})
}
#[derive(Clone, Debug)]
pub struct NodeSchema(Rc<[(&'static str, SchemaField)]>);
impl NodeSchema {
pub fn fields(&self) -> &[(&'static str, SchemaField)] {
&self.0
}
pub fn with_setter(&self, key: &str, setter: SchemaSetter) -> NodeSchema {
NodeSchema(
self.0
.iter()
.map(|(k, field)| {
let mut field = field.clone();
if *k == key {
field.setter = Some(setter.clone());
}
(*k, field)
})
.collect(),
)
}
}
pub fn node_schema(fields: Vec<(&'static str, SchemaField)>) -> Result<NodeSchema, LexicalError> {
check_field_names("nodeSchema", fields.iter().map(|(k, f)| (*k, &f.schema)))?;
Ok(NodeSchema(fields.into()))
}
struct ComposedSchema {
fields_derived_first: Vec<(&'static str, SchemaField)>,
fields_base_first: Vec<(&'static str, SchemaField)>,
}
thread_local! {
static COMPOSED: RefCell<HashMap<TypeId, Rc<ComposedSchema>>> = RefCell::new(HashMap::new());
}
fn composed_schema(node: &dyn LexicalNode) -> Rc<ComposedSchema> {
let id = node.as_any().type_id();
if let Some(composed) = COMPOSED.with(|c| c.borrow().get(&id).cloned()) {
return composed;
}
let chain = node.json_schema_chain();
let mut derived_first: Vec<(&'static str, SchemaField)> = Vec::new();
for schema in &chain {
for (key, field) in schema.fields() {
if !derived_first.iter().any(|(k, _)| k == key) {
derived_first.push((key, field.clone()));
}
}
}
let mut base_first: Vec<(&'static str, SchemaField)> = Vec::new();
for schema in chain.iter().rev() {
for (key, _) in schema.fields() {
if !base_first.iter().any(|(k, _)| k == key) {
let winner = derived_first
.iter()
.find(|(k, _)| k == key)
.expect("a composed key");
base_first.push(winner.clone());
}
}
}
let composed = Rc::new(ComposedSchema {
fields_derived_first: derived_first,
fields_base_first: base_first,
});
COMPOSED.with(|c| c.borrow_mut().insert(id, composed.clone()));
composed
}
pub fn get_composed_schema_fields(node: &dyn LexicalNode) -> Vec<(String, SchemaField)> {
let mut fields: Vec<(String, SchemaField)> = Vec::new();
for required in node.state_configs() {
if required.flat
&& let Some(schema) = required.state_config.schema()
&& !fields.iter().any(|(k, _)| k == required.state_config.key())
{
fields.push((
required.state_config.key().to_owned(),
SchemaField {
schema,
getter: None,
when: None,
setter: None,
derived: false,
},
));
}
}
for (key, field) in &composed_schema(node).fields_derived_first {
fields.retain(|(k, _)| k != key);
fields.push(((*key).to_owned(), field.clone()));
}
fields
}
pub fn walk_export_json(node: &dyn LexicalNode, compact: bool) -> Object {
let composed = composed_schema(node);
let mut json = Object::new();
if compact {
json.insert("type", node.get_type().into());
}
if node.element().is_some() {
json.insert("children", Value::Array(Vec::new()));
}
for (key, field) in &composed.fields_derived_first {
let Some(getter) = &field.getter else {
continue;
};
if compact && field.setter.is_none() {
continue;
}
let mut value = getter(node);
if let Some(when) = &field.when
&& (field.is_compact_default(&value) || !when(node))
{
value = Value::Undefined;
}
if compact && field.is_compact_default(&value) {
continue;
}
json.insert(*key, value);
}
if !compact {
json.insert("type", node.get_type().into());
json.insert("version", 1.0.into());
}
json
}
pub fn walk_update_from_json(node: &mut dyn LexicalNode, json: &Object) {
let composed = composed_schema(node);
for (key, field) in &composed.fields_base_first {
if let Some(setter) = &field.setter {
let parsed = field
.schema
.parse(json.get(key).unwrap_or(&Value::Undefined));
setter(node, parsed);
}
}
}
pub fn export_node_json_once(node: &dyn LexicalNode, compact: bool) -> Object {
node.generated_export_json(compact)
.unwrap_or_else(|| walk_export_json(node, compact))
}
pub fn apply_json_setters(node: &mut dyn LexicalNode, json: &Object) {
if !node.generated_update_from_json(json) {
walk_update_from_json(node, json);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::json::parse;
fn hostile_values() -> Vec<Value> {
let mut values = vec![Value::Undefined];
for text in [
"null",
"true",
"false",
"0",
"-0",
"-1",
"1",
"1.5",
"2",
"3",
"128",
"129",
"1e300",
"\"\"",
"\"0\"",
"\"1\"",
"\"1.5\"",
"\"-1\"",
"\"1e999\"",
"\"0x10\"",
"\" 1\"",
"\"__proto__\"",
"\"toString\"",
"\"bold\"",
"\"code\"",
"\"unmergeable\"",
"\"directionless\"",
"\"token\"",
"\"segmented\"",
"\"normal\"",
"\"ltr\"",
"\"rtl\"",
"\"center\"",
"\"justify\"",
"\"h1\"",
"\"h6\"",
"\"h7\"",
"\"number\"",
"\"bullet\"",
"\"check\"",
"\"ol\"",
"\"ul\"",
"\"x\"",
"\"https://lexical.dev\"",
"[]",
"[\"a\",1,null,\"b\"]",
"[\"b\",\"a\",\"b\"]",
"{}",
"{\"a\":1}",
] {
values.push(parse(text).expect("JSON"));
}
values
}
fn check_agrees(node: &dyn LexicalNode, keys: &[&str], exports: bool) {
for key in keys {
for value in hostile_values() {
let mut json = Object::new();
json.insert(*key, value.clone());
let mut generated = node.clone_node();
assert!(generated.generated_update_from_json(&json));
let mut walked = node.clone_node();
walk_update_from_json(walked.as_node_mut(), &json);
assert_eq!(
format!("{generated:?}"),
format!("{walked:?}"),
"{} {key}: {value}",
node.get_type()
);
if exports {
for compact in [false, true] {
assert_eq!(
Value::Object(
generated
.generated_export_json(compact)
.expect("generated code")
)
.to_string(),
Value::Object(walk_export_json(&*generated, compact)).to_string(),
"{} {key}: {value} (compact: {compact})",
node.get_type()
);
}
}
}
}
}
const ELEMENT_KEYS: [&str; 5] = ["direction", "format", "indent", "textFormat", "textStyle"];
const TEXT_KEYS: [&str; 5] = ["detail", "format", "mode", "style", "text"];
fn keys<'a>(own: &[&'a str], base: &[&'a str]) -> Vec<&'a str> {
own.iter().chain(base).copied().collect()
}
#[test]
fn generated_json_is_the_walk_of_the_schema() {
check_agrees(
&crate::nodes::paragraph::ParagraphNode::default(),
&ELEMENT_KEYS,
false,
);
check_agrees(&crate::nodes::text::TextNode::default(), &TEXT_KEYS, true);
check_agrees(&crate::nodes::tab::TabNode::default(), &TEXT_KEYS, true);
check_agrees(
&crate::nodes::line_break::LineBreakNode::default(),
&[],
true,
);
#[cfg(feature = "rich-text")]
{
check_agrees(
&crate::rich_text::HeadingNode::default(),
&keys(&["tag"], &ELEMENT_KEYS),
false,
);
check_agrees(
&crate::rich_text::QuoteNode::default(),
&ELEMENT_KEYS,
false,
);
}
#[cfg(feature = "list")]
{
check_agrees(
&crate::list::ListNode::default(),
&keys(&["listType", "start", "tag"], &ELEMENT_KEYS),
false,
);
check_agrees(
&crate::list::ListItemNode::default(),
&keys(&["checked", "indent", "value"], &ELEMENT_KEYS),
false,
);
}
#[cfg(feature = "link")]
{
let link = ["rel", "target", "title", "url"];
check_agrees(
&crate::link::LinkNode::default(),
&keys(&link, &ELEMENT_KEYS),
false,
);
check_agrees(
&crate::link::AutoLinkNode::default(),
&keys(&keys(&["isUnlinked"], &link), &ELEMENT_KEYS),
false,
);
}
#[cfg(feature = "code")]
{
check_agrees(
&crate::code::CodeNode::default(),
&keys(&["language", "theme"], &ELEMENT_KEYS),
false,
);
check_agrees(
&crate::code::CodeHighlightNode::default(),
&keys(&["highlightType"], &TEXT_KEYS),
true,
);
}
#[cfg(feature = "mark")]
check_agrees(
&crate::mark::MarkNode::default(),
&keys(&["ids"], &ELEMENT_KEYS),
false,
);
#[cfg(feature = "overflow")]
check_agrees(
&crate::overflow::OverflowNode::default(),
&ELEMENT_KEYS,
false,
);
#[cfg(feature = "hashtag")]
check_agrees(&crate::hashtag::HashtagNode::default(), &TEXT_KEYS, true);
}
}