use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use rkyv::{Archive, Deserialize, Serialize};
use crate::graph::ProvenanceSubKind;
pub type FrameLayoutNodeId = String;
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(derive(Debug, PartialEq, Eq))]
pub enum SplitOrientation {
Vertical,
Horizontal,
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(derive(Debug, PartialEq, Eq))]
pub enum DominantEdge {
Left,
Right,
Top,
Bottom,
}
#[derive(
Debug,
Clone,
PartialEq,
Eq,
PartialOrd,
Ord,
Hash,
Default,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(derive(Debug, PartialEq, Eq))]
pub enum GraphScope {
#[default]
Default,
Source,
User,
Agent,
Moot,
Custom(String),
}
static NEXT_LOCAL_STATEMENT_NONCE: AtomicU64 = AtomicU64::new(1);
static STATEMENT_MINTER_SALT: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
pub fn seed_statement_minter(salt: u64) {
let _ = STATEMENT_MINTER_SALT.set(salt);
}
fn statement_minter_salt() -> u64 {
*STATEMENT_MINTER_SALT.get_or_init(|| {
#[cfg(not(target_arch = "wasm32"))]
{
let bytes = uuid::Uuid::new_v4();
u64::from_le_bytes(bytes.as_bytes()[..8].try_into().expect("8 bytes"))
}
#[cfg(target_arch = "wasm32")]
{
0
}
})
}
pub(crate) fn mint_local_statement_id() -> String {
let timestamp_ms = crate::time::unix_epoch_millis();
let salt = statement_minter_salt();
let nonce = NEXT_LOCAL_STATEMENT_NONCE.fetch_add(1, Ordering::Relaxed);
format!("{timestamp_ms:012x}-{salt:016x}-{nonce:016x}")
}
#[cfg(test)]
mod minting_tests {
use super::*;
#[test]
fn statement_ids_carry_salt_and_stay_unique() {
let a = mint_local_statement_id();
let b = mint_local_statement_id();
assert_ne!(a, b);
let parts: Vec<&str> = a.split('-').collect();
assert_eq!(parts.len(), 3, "ts-salt-counter shape: {a}");
assert_eq!(parts[0].len(), 12);
assert_eq!(parts[1].len(), 16);
assert_eq!(parts[2].len(), 16);
assert_ne!(parts[1], "0000000000000000", "native salt self-seeds");
let b_parts: Vec<&str> = b.split('-').collect();
assert_eq!(parts[1], b_parts[1], "salt is per-process stable");
}
}
#[derive(
Debug,
Clone,
PartialEq,
Eq,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(derive(Debug, PartialEq, Eq))]
pub enum FrameLayoutHint {
SplitHalf {
first: FrameLayoutNodeId,
second: FrameLayoutNodeId,
orientation: SplitOrientation,
},
SplitPamphlet {
members: [FrameLayoutNodeId; 3],
orientation: SplitOrientation,
},
SplitTriptych {
dominant: FrameLayoutNodeId,
dominant_edge: DominantEdge,
wings: [FrameLayoutNodeId; 2],
},
SplitQuartered {
top_left: FrameLayoutNodeId,
top_right: FrameLayoutNodeId,
bottom_left: FrameLayoutNodeId,
bottom_right: FrameLayoutNodeId,
},
}
#[derive(
Debug,
Clone,
PartialEq,
Eq,
PartialOrd,
Ord,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
pub struct NodeImportProvenance {
pub source_id: String,
pub source_label: String,
}
#[derive(
Debug,
Clone,
PartialEq,
Eq,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
pub struct NodeDerivation {
pub sub_kind: ProvenanceSubKind,
pub source_node: String,
pub source_graph: Option<String>,
}
#[derive(
Debug,
Clone,
PartialEq,
Eq,
PartialOrd,
Ord,
Hash,
Default,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
pub struct ImportRecordMembership {
pub node_id: String,
pub suppressed: bool,
}
#[derive(
Debug,
Clone,
PartialEq,
Eq,
PartialOrd,
Ord,
Hash,
Default,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
pub struct ImportRecord {
pub record_id: String,
pub source_id: String,
pub source_label: String,
pub imported_at_secs: u64,
pub memberships: Vec<ImportRecordMembership>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NodeImportRecordSummary {
pub record_id: String,
pub source_id: String,
pub source_label: String,
pub imported_at_secs: u64,
}
pub fn format_imported_at_secs(imported_at_secs: u64) -> String {
time::OffsetDateTime::from_unix_timestamp(imported_at_secs as i64)
.ok()
.and_then(|timestamp| {
timestamp
.format(&time::format_description::well_known::Rfc3339)
.ok()
})
.unwrap_or_else(|| format!("{}s", imported_at_secs))
}
#[derive(
Debug,
Clone,
PartialEq,
Eq,
PartialOrd,
Ord,
Hash,
Default,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
pub enum ClassificationScheme {
#[default]
Udc,
ContentKind,
Custom(String),
}
#[derive(
Debug,
Clone,
PartialEq,
Eq,
PartialOrd,
Ord,
Hash,
Default,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
pub enum ClassificationProvenance {
#[default]
UserAuthored,
Imported,
InheritedFromSource,
RegistryDerived,
AgentSuggested,
CommunitySynced,
}
#[derive(
Debug,
Clone,
PartialEq,
Eq,
PartialOrd,
Ord,
Hash,
Default,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
pub enum ClassificationStatus {
Accepted,
#[default]
Suggested,
Rejected,
Verified,
Imported,
}
#[derive(
Debug, Clone, PartialEq, Archive, Serialize, Deserialize, serde::Serialize, serde::Deserialize,
)]
pub struct NodeClassification {
pub scheme: ClassificationScheme,
pub value: String,
pub label: Option<String>,
pub confidence: f32,
pub provenance: ClassificationProvenance,
pub status: ClassificationStatus,
pub primary: bool,
}
#[derive(
Debug,
Clone,
PartialEq,
Eq,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
pub struct NodeProperty {
#[serde(default = "mint_local_statement_id")]
pub statement_id: String,
pub predicate: String,
pub value: String,
#[serde(default)]
pub datatype: Option<String>,
#[serde(default)]
pub lang: Option<String>,
#[serde(default)]
pub graph_scope: GraphScope,
#[serde(default)]
pub provenance_iri: Option<String>,
#[serde(default)]
pub asserted_at_ms: Option<u64>,
}
impl NodeProperty {
pub fn new(predicate: String, value: String) -> Self {
Self {
statement_id: mint_local_statement_id(),
predicate,
value,
datatype: None,
lang: None,
graph_scope: GraphScope::Default,
provenance_iri: None,
asserted_at_ms: None,
}
}
pub fn with_graph_scope(mut self, graph_scope: GraphScope) -> Self {
self.graph_scope = graph_scope;
self
}
pub fn with_metadata(
mut self,
provenance_iri: Option<String>,
asserted_at_ms: Option<u64>,
) -> Self {
self.provenance_iri = provenance_iri;
self.asserted_at_ms = asserted_at_ms;
self
}
pub fn content_eq(&self, other: &Self) -> bool {
self.predicate == other.predicate
&& self.value == other.value
&& self.datatype == other.datatype
&& self.lang == other.lang
&& self.graph_scope == other.graph_scope
}
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(
compare(PartialEq, PartialOrd),
derive(Debug, PartialEq, Eq, PartialOrd, Ord)
)]
pub enum ImageRole {
Favicon,
Preview,
Snapshot,
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Hash,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(derive(Debug, PartialEq, Eq))]
pub struct ImageRef {
#[serde(with = "digest_hex")]
pub digest: [u8; 32],
pub width: u32,
pub height: u32,
}
impl ImageRef {
pub fn new(digest: [u8; 32], width: u32, height: u32) -> Self {
Self {
digest,
width,
height,
}
}
pub fn hex(&self) -> String {
use std::fmt::Write;
let mut out = String::with_capacity(64);
for byte in &self.digest {
let _ = write!(out, "{byte:02x}");
}
out
}
}
mod digest_hex {
use serde::{Deserialize, Deserializer, Serializer, de::Error};
pub fn serialize<S: Serializer>(digest: &[u8; 32], serializer: S) -> Result<S::Ok, S::Error> {
use std::fmt::Write;
let mut hex = String::with_capacity(64);
for byte in digest {
let _ = write!(hex, "{byte:02x}");
}
serializer.serialize_str(&hex)
}
pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<[u8; 32], D::Error> {
let hex = String::deserialize(deserializer)?;
let bytes = hex.as_bytes();
if bytes.len() != 64 {
return Err(D::Error::invalid_length(bytes.len(), &"64 hex characters"));
}
let nibble = |b: u8| -> Result<u8, D::Error> {
(b as char)
.to_digit(16)
.map(|d| d as u8)
.ok_or_else(|| D::Error::custom("digest is not valid hex"))
};
let mut out = [0u8; 32];
for (i, pair) in bytes.chunks_exact(2).enumerate() {
out[i] = (nibble(pair[0])? << 4) | nibble(pair[1])?;
}
Ok(out)
}
}
#[derive(
Debug,
Clone,
PartialEq,
Eq,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(derive(Debug, PartialEq, Eq))]
pub enum BadgeIcon {
Emoji(String),
Lucide(String),
None,
}
#[derive(
Debug,
Clone,
Default,
PartialEq,
Eq,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(derive(Debug, PartialEq, Eq))]
pub struct NodeTagPresentationState {
pub ordered_tags: Vec<String>,
pub icon_overrides: HashMap<String, BadgeIcon>,
}