use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum NativePaneRail {
Wallet,
Redirect,
}
impl NativePaneRail {
pub fn as_wire(self) -> &'static str {
match self {
Self::Wallet => "wallet",
Self::Redirect => "redirect",
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
pub enum NativePaneVisibility {
#[default]
Always,
EmbeddedOnly,
}
impl NativePaneVisibility {
pub fn as_wire(self) -> &'static str {
match self {
Self::Always => "always",
Self::EmbeddedOnly => "embedded_only",
}
}
pub fn from_wire(raw: Option<&Value>) -> Self {
match raw.and_then(Value::as_str) {
Some("embedded_only") => Self::EmbeddedOnly,
_ => Self::Always,
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
pub enum NativePaneOpenTarget {
#[default]
Tab,
Popup,
}
impl NativePaneOpenTarget {
pub fn as_wire(self) -> &'static str {
match self {
Self::Tab => "tab",
Self::Popup => "popup",
}
}
pub fn from_wire(raw: Option<&Value>) -> Self {
match raw.and_then(Value::as_str) {
Some("popup") => Self::Popup,
_ => Self::Tab,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StripeNativePane {
pub method: String,
pub enabled: bool,
pub label: String,
pub label_translations: BTreeMap<String, String>,
pub sublabel: Option<String>,
pub sublabel_translations: BTreeMap<String, String>,
pub category: String,
pub icon: String,
pub icon_svg: String,
pub display_order: i64,
pub visibility: NativePaneVisibility,
pub open_in: NativePaneOpenTarget,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct NativePaneView {
pub method: String,
pub rail: String,
pub label: String,
pub sublabel: String,
pub category: String,
pub icon: Option<String>,
pub icon_svg: Option<String>,
pub display_order: i64,
pub payment_method: Option<String>,
pub payment_method_type: Option<String>,
pub payment_method_data: Option<Value>,
pub requires_billing_country: Option<bool>,
pub embedded_only: Option<bool>,
pub open_in: Option<String>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NativePaneMethodInfo {
pub key: &'static str,
pub rail: NativePaneRail,
pub default_label: &'static str,
pub default_sublabel: &'static str,
pub default_category: &'static str,
pub default_icon: &'static str,
}
pub const STRIPE_NATIVE_PANE_METHODS: &[NativePaneMethodInfo] = &[
NativePaneMethodInfo {
key: "apple_pay",
rail: NativePaneRail::Wallet,
default_label: "Apple Pay",
default_sublabel: "Pay with Apple Pay",
default_category: "wallet",
default_icon: "apple",
},
NativePaneMethodInfo {
key: "google_pay",
rail: NativePaneRail::Wallet,
default_label: "Google Pay",
default_sublabel: "Pay with Google Pay",
default_category: "wallet",
default_icon: "google",
},
NativePaneMethodInfo {
key: "link",
rail: NativePaneRail::Wallet,
default_label: "Link",
default_sublabel: "Pay with saved details",
default_category: "wallet",
default_icon: "wallet",
},
NativePaneMethodInfo {
key: "klarna",
rail: NativePaneRail::Redirect,
default_label: "Klarna",
default_sublabel: "Pay later or in instalments",
default_category: "bnpl",
default_icon: "bnpl",
},
NativePaneMethodInfo {
key: "affirm",
rail: NativePaneRail::Redirect,
default_label: "Affirm",
default_sublabel: "Pay over time",
default_category: "bnpl",
default_icon: "bnpl",
},
NativePaneMethodInfo {
key: "ideal",
rail: NativePaneRail::Redirect,
default_label: "iDEAL",
default_sublabel: "Pay from your bank",
default_category: "bank_redirect",
default_icon: "bank",
},
NativePaneMethodInfo {
key: "alipay",
rail: NativePaneRail::Redirect,
default_label: "Alipay",
default_sublabel: "Pay with Alipay",
default_category: "wallet",
default_icon: "wallet",
},
NativePaneMethodInfo {
key: "revolut_pay",
rail: NativePaneRail::Redirect,
default_label: "Revolut Pay",
default_sublabel: "Pay with Revolut",
default_category: "wallet",
default_icon: "wallet",
},
NativePaneMethodInfo {
key: "amazon_pay",
rail: NativePaneRail::Redirect,
default_label: "Amazon Pay",
default_sublabel: "Pay with Amazon",
default_category: "wallet",
default_icon: "wallet",
},
];
pub const NATIVE_PANE_ICON_KEYS: &[&str] =
&["wallet", "card", "bank", "apple", "google", "bnpl", "cash"];
pub const NATIVE_PANE_CATEGORY_KEYS: &[&str] = &[
"wallet",
"card",
"bnpl",
"bank_redirect",
"bank_transfer",
"cash",
];
pub const NATIVE_PANES_MAX: usize = 12;
pub const NATIVE_PANES_METADATA_KEY: &str = "native_panes";
pub const CHECKOUT_EVENT_KINDS: &[&str] = &[
"native_pane_selected",
"native_pane_tab_opened",
"native_pane_tab_blocked",
"native_pane_abandoned",
"native_pane_returned",
];
pub fn native_pane_method_info(method: &str) -> Option<&'static NativePaneMethodInfo> {
STRIPE_NATIVE_PANE_METHODS.iter().find(|m| m.key == method)
}
pub fn default_native_pane(method: &str) -> StripeNativePane {
let info = native_pane_method_info(method);
StripeNativePane {
method: method.to_owned(),
enabled: true,
label: String::new(),
label_translations: BTreeMap::new(),
sublabel: None,
sublabel_translations: BTreeMap::new(),
category: String::new(),
icon: info.map(|i| i.default_icon).unwrap_or_default().to_owned(),
icon_svg: String::new(),
display_order: 0,
visibility: NativePaneVisibility::Always,
open_in: NativePaneOpenTarget::Tab,
}
}
fn str_or_empty(row: &Map<String, Value>, key: &str) -> String {
row.get(key)
.and_then(Value::as_str)
.unwrap_or_default()
.to_owned()
}
fn parse_translations(raw: Option<&Value>) -> BTreeMap<String, String> {
let mut out = BTreeMap::new();
if let Some(Value::Object(map)) = raw {
for (locale, value) in map {
if let Some(text) = value.as_str()
&& !text.is_empty()
{
out.insert(locale.clone(), text.to_owned());
}
}
}
out
}
fn int_or_zero(raw: Option<&Value>) -> i64 {
let wide = match raw {
Some(Value::Number(n)) => n
.as_i64()
.or_else(|| n.as_f64().filter(|f| f.is_finite()).map(|f| f as i64))
.unwrap_or(0),
Some(Value::String(s)) => s
.trim()
.parse::<f64>()
.ok()
.filter(|f| f.is_finite())
.map(|f| f as i64)
.unwrap_or(0),
_ => 0,
};
wide.clamp(i64::from(i32::MIN), i64::from(i32::MAX))
}
pub fn decode_native_panes(raw: &Value) -> Option<Vec<StripeNativePane>> {
let rows = raw.as_array()?;
let decode_row = |row: &Map<String, Value>, method: String| StripeNativePane {
method,
enabled: row.get("enabled") != Some(&Value::Bool(false)),
label: str_or_empty(row, "label"),
label_translations: parse_translations(row.get("label_translations")),
sublabel: row
.get("sublabel")
.and_then(Value::as_str)
.map(str::to_owned),
sublabel_translations: parse_translations(row.get("sublabel_translations")),
category: str_or_empty(row, "category"),
icon: str_or_empty(row, "icon"),
icon_svg: str_or_empty(row, "icon_svg"),
display_order: int_or_zero(row.get("display_order")),
visibility: NativePaneVisibility::from_wire(row.get("visibility")),
open_in: NativePaneOpenTarget::from_wire(row.get("open_in")),
};
let mut index_by_method: BTreeMap<String, usize> = BTreeMap::new();
let mut out: Vec<StripeNativePane> = Vec::new();
for entry in rows {
if out.len() >= NATIVE_PANES_MAX {
break;
}
let Some(row) = entry.as_object() else {
continue;
};
let method = str_or_empty(row, "method").trim().to_owned();
if method.is_empty() {
continue;
}
if let Some(&kept) = index_by_method.get(&method) {
let enabled = row.get("enabled") != Some(&Value::Bool(false));
if enabled && !out[kept].enabled {
out[kept] = decode_row(row, method);
}
continue;
}
index_by_method.insert(method.clone(), out.len());
out.push(decode_row(row, method));
}
Some(out)
}
pub fn encode_native_panes(panes: &[StripeNativePane]) -> Value {
let non_empty = |map: &BTreeMap<String, String>| -> Option<Map<String, Value>> {
let entries: Map<String, Value> = map
.iter()
.filter(|(_, v)| !v.trim().is_empty())
.map(|(k, v)| (k.clone(), Value::String(v.clone())))
.collect();
(!entries.is_empty()).then_some(entries)
};
let rows: Vec<Value> = panes
.iter()
.take(NATIVE_PANES_MAX)
.map(|pane| {
let mut row = Map::new();
row.insert("method".into(), Value::String(pane.method.clone()));
row.insert("enabled".into(), Value::Bool(pane.enabled));
if !pane.label.trim().is_empty() {
row.insert("label".into(), Value::String(pane.label.trim().to_owned()));
}
if let Some(translations) = non_empty(&pane.label_translations) {
row.insert("label_translations".into(), Value::Object(translations));
}
if let Some(sublabel) = &pane.sublabel {
row.insert("sublabel".into(), Value::String(sublabel.clone()));
}
if let Some(translations) = non_empty(&pane.sublabel_translations) {
row.insert("sublabel_translations".into(), Value::Object(translations));
}
if !pane.category.trim().is_empty() {
row.insert(
"category".into(),
Value::String(pane.category.trim().to_owned()),
);
}
if !pane.icon.trim().is_empty() {
row.insert("icon".into(), Value::String(pane.icon.trim().to_owned()));
}
if !pane.icon_svg.trim().is_empty() {
row.insert(
"icon_svg".into(),
Value::String(pane.icon_svg.trim().to_owned()),
);
}
row.insert(
"display_order".into(),
Value::from(
pane.display_order
.clamp(i64::from(i32::MIN), i64::from(i32::MAX)),
),
);
row.insert(
"visibility".into(),
Value::String(pane.visibility.as_wire().to_owned()),
);
row.insert(
"open_in".into(),
Value::String(pane.open_in.as_wire().to_owned()),
);
Value::Object(row)
})
.collect();
Value::Array(rows)
}
#[derive(Debug, Clone, Copy)]
pub struct FocusedCheckoutUrlParams<'a> {
pub checkout_base_url: &'a str,
pub merchant_id: &'a str,
pub payment_id: &'a str,
pub method: &'a str,
pub locale: Option<&'a str>,
pub custom_fields_collected: bool,
}
pub fn focused_checkout_url(params: &FocusedCheckoutUrlParams<'_>) -> String {
let base = params.checkout_base_url.trim_end_matches('/');
let mut url = format!(
"{base}/pay/{}/{}?pane={}",
encode_path_segment(params.merchant_id),
encode_path_segment(params.payment_id),
encode_query_value(params.method),
);
if let Some(locale) = params.locale.filter(|l| !l.is_empty()) {
url.push_str("&locale=");
url.push_str(&encode_query_value(locale));
}
if params.custom_fields_collected {
url.push_str("&cf=1");
}
url
}
fn encode_path_segment(s: &str) -> String {
percent_encode(s, false)
}
fn encode_query_value(s: &str) -> String {
percent_encode(s, true)
}
fn percent_encode(s: &str, form: bool) -> String {
let mut out = String::with_capacity(s.len());
for b in s.bytes() {
match b {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' => out.push(b as char),
b'~' if !form => out.push('~'),
b'*' if form => out.push('*'),
b' ' if form => out.push('+'),
_ => {
out.push('%');
out.push_str(&format!("{b:02X}"));
}
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn catalog_has_unique_keys() {
let mut keys: Vec<_> = STRIPE_NATIVE_PANE_METHODS.iter().map(|m| m.key).collect();
keys.sort_unstable();
keys.dedup();
assert_eq!(keys.len(), STRIPE_NATIVE_PANE_METHODS.len());
}
#[test]
fn catalog_never_offers_the_card_rail() {
for key in ["card", "credit", "debit"] {
assert!(native_pane_method_info(key).is_none());
}
}
#[test]
fn catalog_marks_exactly_the_browser_wallets_as_the_wallet_rail() {
let wallets: Vec<_> = STRIPE_NATIVE_PANE_METHODS
.iter()
.filter(|m| m.rail == NativePaneRail::Wallet)
.map(|m| m.key)
.collect();
assert_eq!(wallets, ["apple_pay", "google_pay", "link"]);
}
#[test]
fn decode_returns_none_for_a_non_array() {
assert!(decode_native_panes(&Value::Null).is_none());
assert!(decode_native_panes(&json!({})).is_none());
assert!(decode_native_panes(&json!("[]")).is_none());
}
#[test]
fn decode_reads_a_stored_row() {
let decoded = decode_native_panes(&json!([{
"method": "apple_pay",
"enabled": true,
"label": "Apple Pay",
"label_translations": {"de": "Apple Pay DE"},
"sublabel": "",
"category": "wallet",
"icon": "apple",
"display_order": 2,
}]))
.unwrap();
assert_eq!(decoded.len(), 1);
let pane = &decoded[0];
assert_eq!(pane.method, "apple_pay");
assert!(pane.enabled);
assert_eq!(pane.label, "Apple Pay");
assert_eq!(pane.label_translations["de"], "Apple Pay DE");
assert_eq!(pane.sublabel.as_deref(), Some(""));
assert_eq!(pane.category, "wallet");
assert_eq!(pane.icon, "apple");
assert_eq!(pane.display_order, 2);
}
#[test]
fn decode_drops_methodless_rows_and_keeps_the_first_duplicate() {
let decoded = decode_native_panes(&json!([
{"label": "nameless"},
{"method": "klarna", "label": "first"},
{"method": "klarna", "label": "second"},
]))
.unwrap();
assert_eq!(decoded.len(), 1);
assert_eq!(decoded[0].label, "first");
}
#[test]
fn decode_keeps_the_enabled_duplicate_the_router_renders() {
let decoded = decode_native_panes(&json!([
{"method": "klarna", "enabled": false},
{"method": "klarna", "enabled": true, "label": "Later"},
]))
.unwrap();
assert_eq!(decoded.len(), 1);
assert!(decoded[0].enabled);
assert_eq!(decoded[0].label, "Later");
}
#[test]
fn decode_caps_the_list() {
let rows: Vec<Value> = (0..NATIVE_PANES_MAX + 5)
.map(|i| json!({"method": format!("m{i}")}))
.collect();
assert_eq!(
decode_native_panes(&Value::Array(rows)).unwrap().len(),
NATIVE_PANES_MAX
);
}
#[test]
fn decode_distinguishes_an_absent_sublabel_from_a_deliberately_blank_one() {
let absent = decode_native_panes(&json!([{"method": "apple_pay"}])).unwrap();
assert_eq!(absent[0].sublabel, None);
let blank = decode_native_panes(&json!([{"method": "apple_pay", "sublabel": ""}])).unwrap();
assert_eq!(blank[0].sublabel.as_deref(), Some(""));
}
#[test]
fn decode_tolerates_junk_in_every_optional_field() {
let decoded = decode_native_panes(&json!([{
"method": "ideal",
"enabled": "yes",
"label": 42,
"label_translations": {"de": 7, "fr": "Banque"},
"category": null,
"display_order": "nope",
}]))
.unwrap();
let pane = &decoded[0];
assert_eq!(pane.method, "ideal");
assert!(pane.enabled);
assert_eq!(pane.label, "");
assert_eq!(pane.label_translations.len(), 1);
assert_eq!(pane.label_translations["fr"], "Banque");
assert_eq!(pane.category, "");
assert_eq!(pane.display_order, 0);
}
#[test]
fn decode_accepts_a_numeric_string_display_order() {
let decoded =
decode_native_panes(&json!([{"method": "ideal", "display_order": "3"}])).unwrap();
assert_eq!(decoded[0].display_order, 3);
}
#[test]
fn decode_clamps_display_order_into_the_router_i32_range() {
let decoded = decode_native_panes(&json!([
{"method": "ideal", "display_order": 3_000_000_000_i64},
{"method": "klarna", "display_order": -3_000_000_000_i64},
]))
.unwrap();
assert_eq!(decoded[0].display_order, i64::from(i32::MAX));
assert_eq!(decoded[1].display_order, i64::from(i32::MIN));
let round_tripped = decode_native_panes(&encode_native_panes(&decoded)).unwrap();
assert_eq!(round_tripped, decoded);
}
#[test]
fn encode_clamps_display_order_that_never_went_through_decode() {
let mut pane = default_native_pane("ideal");
pane.display_order = 1_753_000_000_000;
let encoded = encode_native_panes(&[pane]);
assert_eq!(
encoded[0].get("display_order"),
Some(&Value::from(i32::MAX))
);
}
#[test]
fn encode_round_trips_through_decode() {
let mut pane = default_native_pane("apple_pay");
pane.label = "Wallet".into();
pane.label_translations
.insert("de".into(), "Geldbörse".into());
pane.display_order = 3;
let round_tripped =
decode_native_panes(&encode_native_panes(std::slice::from_ref(&pane))).unwrap();
assert_eq!(round_tripped[0], pane);
}
#[test]
fn encode_omits_empty_optional_fields() {
let encoded = encode_native_panes(&[default_native_pane("apple_pay")]);
let row = encoded[0].as_object().unwrap();
assert!(!row.contains_key("label"));
assert!(!row.contains_key("sublabel"));
assert!(!row.contains_key("category"));
assert!(!row.contains_key("icon_svg"));
assert_eq!(row["method"], "apple_pay");
}
#[test]
fn encode_preserves_a_deliberately_blank_sublabel() {
let mut pane = default_native_pane("apple_pay");
pane.sublabel = Some(String::new());
let encoded = encode_native_panes(std::slice::from_ref(&pane));
assert_eq!(encoded[0]["sublabel"], "");
}
#[test]
fn encode_drops_blank_translation_entries() {
let mut pane = default_native_pane("apple_pay");
pane.label_translations.insert("de".into(), " ".into());
pane.label_translations
.insert("fr".into(), "Portefeuille".into());
let encoded = encode_native_panes(std::slice::from_ref(&pane));
assert_eq!(
encoded[0]["label_translations"],
json!({"fr": "Portefeuille"})
);
}
#[test]
fn visibility_defaults_to_always_and_round_trips_embedded_only() {
let decoded = decode_native_panes(&json!([{"method": "apple_pay"}])).unwrap();
assert_eq!(decoded[0].visibility, NativePaneVisibility::Always);
let mut pane = default_native_pane("apple_pay");
pane.visibility = NativePaneVisibility::EmbeddedOnly;
let round_tripped =
decode_native_panes(&encode_native_panes(std::slice::from_ref(&pane))).unwrap();
assert_eq!(
round_tripped[0].visibility,
NativePaneVisibility::EmbeddedOnly
);
}
#[test]
fn visibility_degrades_an_unknown_stored_value_instead_of_dropping_the_row() {
let decoded =
decode_native_panes(&json!([{"method": "apple_pay", "visibility": "sometimes"}]))
.unwrap();
assert_eq!(decoded.len(), 1);
assert_eq!(decoded[0].visibility, NativePaneVisibility::Always);
}
#[test]
fn open_in_defaults_to_tab_and_round_trips_popup() {
let decoded = decode_native_panes(&json!([{"method": "apple_pay"}])).unwrap();
assert_eq!(decoded[0].open_in, NativePaneOpenTarget::Tab);
let mut pane = default_native_pane("apple_pay");
pane.open_in = NativePaneOpenTarget::Popup;
let round_tripped =
decode_native_panes(&encode_native_panes(std::slice::from_ref(&pane))).unwrap();
assert_eq!(round_tripped[0].open_in, NativePaneOpenTarget::Popup);
}
#[test]
fn open_in_degrades_an_unknown_stored_value_instead_of_dropping_the_row() {
let decoded =
decode_native_panes(&json!([{"method": "apple_pay", "open_in": "modal"}])).unwrap();
assert_eq!(decoded.len(), 1);
assert_eq!(decoded[0].open_in, NativePaneOpenTarget::Tab);
}
#[test]
fn native_pane_view_keeps_open_in_optional() {
let older: NativePaneView =
serde_json::from_value(json!({"method": "apple_pay", "rail": "wallet"})).unwrap();
assert_eq!(older.open_in, None);
let newer: NativePaneView = serde_json::from_value(
json!({"method": "apple_pay", "rail": "wallet", "open_in": "popup"}),
)
.unwrap();
assert_eq!(newer.open_in.as_deref(), Some("popup"));
}
#[test]
fn clone_copies_the_translation_maps_rather_than_sharing_them() {
let mut pane = default_native_pane("klarna");
pane.label_translations.insert("de".into(), "Klarna".into());
let mut copy = pane.clone();
copy.label_translations
.insert("de".into(), "changed".into());
assert_eq!(pane.label_translations["de"], "Klarna");
}
#[test]
fn focused_url_builds_a_top_level_single_method_link() {
let url = focused_checkout_url(&FocusedCheckoutUrlParams {
checkout_base_url: "https://checkout.delopay.net",
merchant_id: "merchant_1",
payment_id: "pay_123",
method: "apple_pay",
locale: None,
custom_fields_collected: false,
});
assert_eq!(
url,
"https://checkout.delopay.net/pay/merchant_1/pay_123?pane=apple_pay"
);
}
#[test]
fn focused_url_tolerates_a_trailing_slash_and_adds_the_locale() {
let url = focused_checkout_url(&FocusedCheckoutUrlParams {
checkout_base_url: "https://checkout.delopay.net/",
merchant_id: "merchant_1",
payment_id: "pay_123",
method: "klarna",
locale: Some("de"),
custom_fields_collected: false,
});
assert_eq!(
url,
"https://checkout.delopay.net/pay/merchant_1/pay_123?pane=klarna&locale=de"
);
}
#[test]
fn focused_url_escapes_path_segments() {
let url = focused_checkout_url(&FocusedCheckoutUrlParams {
checkout_base_url: "https://checkout.delopay.net",
merchant_id: "a/b",
payment_id: "c d",
method: "ideal",
locale: None,
custom_fields_collected: false,
});
assert_eq!(
url,
"https://checkout.delopay.net/pay/a%2Fb/c%20d?pane=ideal"
);
}
#[test]
fn focused_url_adds_the_custom_fields_hint() {
let url = focused_checkout_url(&FocusedCheckoutUrlParams {
checkout_base_url: "https://checkout.delopay.net",
merchant_id: "merchant_1",
payment_id: "pay_123",
method: "apple_pay",
locale: None,
custom_fields_collected: true,
});
assert_eq!(
url,
"https://checkout.delopay.net/pay/merchant_1/pay_123?pane=apple_pay&cf=1"
);
}
#[test]
fn native_pane_view_deserializes_from_the_wire_shape() {
let view: NativePaneView = serde_json::from_value(json!({
"method": "klarna",
"rail": "redirect",
"label": "Klarna",
"sublabel": "Pay later",
"category": "bnpl",
"icon": "bnpl",
"display_order": 1,
"payment_method": "pay_later",
"payment_method_type": "klarna",
"payment_method_data": {"pay_later": {"klarna_redirect": {}}},
"requires_billing_country": true,
"some_future_field": "kept",
}))
.unwrap();
assert_eq!(view.method, "klarna");
assert_eq!(view.rail, "redirect");
assert_eq!(view.display_order, 1);
assert_eq!(view.payment_method.as_deref(), Some("pay_later"));
assert_eq!(view.payment_method_type.as_deref(), Some("klarna"));
assert_eq!(view.requires_billing_country, Some(true));
assert_eq!(view.embedded_only, None);
assert_eq!(
view.extra.get("some_future_field"),
Some(&Value::String("kept".into()))
);
let reserialized = serde_json::to_value(&view).unwrap();
assert_eq!(reserialized["some_future_field"], "kept");
}
#[test]
fn checkout_event_vocabulary_matches_the_router_enum() {
assert_eq!(
CHECKOUT_EVENT_KINDS,
[
"native_pane_selected",
"native_pane_tab_opened",
"native_pane_tab_blocked",
"native_pane_abandoned",
"native_pane_returned",
]
);
}
}