use euclid::default::Point2D;
use petgraph::algo::{astar, dijkstra, has_path_connecting, kosaraju_scc};
#[cfg(test)]
use petgraph::stable_graph::NodeIndex;
use petgraph::visit::{EdgeRef, IntoEdgeReferences};
use rkyv::{Archive, Archived, Deserialize, Place, Resolver, Serialize, rancor::Fallible};
use std::collections::{BTreeMap, HashMap, HashSet};
use uuid::Uuid;
pub use chartulary::stemma::TransitionKind as NodeHistoryTransitionKind;
use crate::address::{Address, AddressKind, address_from_url, cached_host_from_url, detect_mime};
use crate::persistence::{
GraphSnapshot, PersistedAddress, PersistedArrangementEdgeData, PersistedArrangementSubKind,
PersistedContainmentEdgeData, PersistedContainmentSubKind, PersistedEdge, PersistedEdgeFamily,
PersistedImportedEdgeData, PersistedImportedSubKind, PersistedNavigationTrigger, PersistedNode,
PersistedNodeSessionState, PersistedProvenanceEdgeData, PersistedProvenanceSubKind,
PersistedSemanticEdgeData, PersistedSemanticSubKind, PersistedTraversalEdgeData,
PersistedTraversalMetrics, PersistedTraversalRecord,
};
#[allow(unused_imports)] use crate::types::{
ClassificationProvenance, ClassificationScheme, ClassificationStatus, DominantEdge,
FrameLayoutHint, FrameLayoutNodeId, GraphScope, ImportRecord, ImportRecordMembership,
NodeClassification, NodeImportProvenance, NodeImportRecordSummary, NodeTagPresentationState,
SplitOrientation, format_imported_at_secs,
};
pub mod apply;
pub mod capture;
pub mod cross_graph;
pub mod journal;
pub use cross_graph::ComponentCopy;
pub mod edge_data;
pub mod edge_payload;
pub mod edge_taxonomy;
pub mod facet_projection;
pub mod filter;
#[cfg(feature = "fixtures")]
pub mod fixtures;
pub mod history;
pub mod identity;
pub mod import_records;
pub mod node;
pub mod node_facets;
pub mod node_props;
pub mod source_time;
mod chart;
mod field_ops;
pub(crate) use identity::UuidAsBytes;
pub use identity::{EdgeKey, GraphDirection, GraphIndex, GraphViewId, NodeKey};
pub use node::Node;
pub use node_facets::{NodeFacetStore, VisitHistoryFacet};
pub use history::{
NodeHistoryBranchAlternative, NodeHistoryBranchProjection, NodeHistoryBranchVisit,
NodeHistoryOwner, NodeHistoryProjection, NodeHistorySemanticSummary, RecentVisit,
SharedNavigationMemory,
};
pub use capture::{
CapturedDelta, GraphTableStats, replay_captured_deltas, replay_captured_deltas_onto,
set_captured_delta_hook,
};
pub use journal::{AttributedDelta, GraphJournal, USER_AUTHOR, journal_capture_hook};
pub use source_time::{SourceExtent, SourceTime};
pub use codicil::{LogId, Seq};
pub use edge_data::{
ArrangementData, ContainmentData, EdgeMetrics, ImportedData, ProvenanceData, REL_VOCAB,
SemanticData, SemanticStatement, SemanticStatementSpec, StatementAssert, Traversal,
TraversalData, all_semantic_sub_kinds, predicate_iri, sub_kind_from_iri,
};
pub use edge_payload::EdgePayload;
pub use edge_taxonomy::{
ArrangementSubKind, ContainmentSubKind, EdgeAssertion, EdgeFamily, ImportedSubKind,
NavigationTrigger, ProvenanceSubKind, RelationDurability, RelationKind, RelationSelector,
SemanticSubKind,
};
pub use numen::{
COUPLING_VOCAB, Coupling, CouplingId, CouplingResponse, EdgePath, EdgePathRule, Falloff, Field,
FieldDefinition, FieldExtent, FieldId, FieldLifecycle, NodeSelector, ScalarField, VectorField,
};
#[derive(Debug, Clone, PartialEq, Eq, Archive, Serialize, Deserialize)]
pub struct DissolvedTraversalRecord {
#[rkyv(with = UuidAsBytes)]
pub from_node_id: Uuid,
#[rkyv(with = UuidAsBytes)]
pub to_node_id: Uuid,
pub traversals: Vec<Traversal>,
}
fn normalize_import_record_memberships(memberships: &mut Vec<ImportRecordMembership>) {
memberships.sort_by(|left, right| {
left.node_id
.cmp(&right.node_id)
.then_with(|| left.suppressed.cmp(&right.suppressed))
});
let mut deduped: Vec<ImportRecordMembership> = Vec::with_capacity(memberships.len());
for membership in memberships.drain(..) {
if let Some(existing) = deduped.last_mut()
&& existing.node_id == membership.node_id
{
existing.suppressed &= membership.suppressed;
continue;
}
deduped.push(membership);
}
*memberships = deduped;
}
pub(crate) fn normalize_import_records(import_records: &mut Vec<ImportRecord>) {
let mut merged = BTreeMap::<String, ImportRecord>::new();
for mut record in import_records.drain(..) {
normalize_import_record_memberships(&mut record.memberships);
if record.record_id.trim().is_empty() {
continue;
}
let entry = merged
.entry(record.record_id.clone())
.or_insert_with(|| ImportRecord {
record_id: record.record_id.clone(),
source_id: record.source_id.clone(),
source_label: record.source_label.clone(),
imported_at_secs: record.imported_at_secs,
memberships: Vec::new(),
});
if entry.source_id.is_empty() {
entry.source_id = record.source_id.clone();
}
if entry.source_label.is_empty() {
entry.source_label = record.source_label.clone();
}
if entry.imported_at_secs == 0 {
entry.imported_at_secs = record.imported_at_secs;
} else if record.imported_at_secs != 0 {
entry.imported_at_secs = entry.imported_at_secs.min(record.imported_at_secs);
}
entry.memberships.extend(record.memberships);
}
*import_records = merged.into_values().collect();
for record in import_records.iter_mut() {
normalize_import_record_memberships(&mut record.memberships);
}
import_records.sort_by(|left, right| {
left.source_label
.cmp(&right.source_label)
.then_with(|| left.imported_at_secs.cmp(&right.imported_at_secs))
.then_with(|| left.record_id.cmp(&right.record_id))
});
}
pub(crate) fn current_unix_timestamp_secs() -> u64 {
crate::time::unix_epoch_seconds()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct RelationView {
pub from: NodeKey,
pub to: NodeKey,
pub kind: RelationKind,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SemanticEdgeView {
pub from: NodeKey,
pub to: NodeKey,
pub sub_kind: SemanticSubKind,
pub label: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ArrangementEdgeView {
pub from: NodeKey,
pub to: NodeKey,
pub sub_kind: ArrangementSubKind,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ContainmentEdgeView {
pub from: NodeKey,
pub to: NodeKey,
pub sub_kind: ContainmentSubKind,
}
#[derive(Clone)]
pub struct Graph {
pub(crate) inner: chartulary::Graph<Node, EdgePayload>,
pub(crate) facets: chartulary::FacetStore<Uuid>,
pub(crate) url_to_nodes: HashMap<String, Vec<NodeKey>>,
pub(crate) import_records: Vec<ImportRecord>,
pub(crate) fields: HashMap<FieldId, Field>,
pub(crate) couplings: HashMap<CouplingId, Coupling>,
pub(crate) nav: SharedNavigationMemory,
revision: u64,
current_session: u64,
}
impl Graph {
pub fn new() -> Self {
Self {
inner: chartulary::Graph::new(),
facets: chartulary::FacetStore::new(),
url_to_nodes: HashMap::new(),
import_records: Vec::new(),
fields: HashMap::new(),
couplings: HashMap::new(),
nav: SharedNavigationMemory::empty(),
revision: 0,
current_session: 0,
}
}
pub fn set_current_session(&mut self, session: u64) {
self.current_session = session;
}
pub fn revision(&self) -> u64 {
self.revision
}
fn bump_revision(&mut self) {
self.revision = self.revision.wrapping_add(1);
}
const NODE_NAMESPACE: Uuid = Uuid::from_u128(0x6D65_7265_4E4F_4445_6E61_6D65_7370_6163);
pub fn node_namespace_id(url: &str) -> Uuid {
Uuid::new_v5(&Self::NODE_NAMESPACE, url.as_bytes())
}
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn add_node(&mut self, url: String, position: Point2D<f32>) -> NodeKey {
self.add_node_with_id(Uuid::new_v4(), url, position)
}
pub(crate) fn add_node_with_id(
&mut self,
id: Uuid,
url: String,
_position: Point2D<f32>,
) -> NodeKey {
let primary_address = address_from_url(&url);
let mut container = chartulary::Container::with_identity(id)
.with_address_record(primary_address)
.with_title(url.clone());
container.media_type = detect_mime(&url, None);
let key = self.inner.insert(Node {
container,
images: std::collections::BTreeMap::new(),
});
self.set_node_last_visited_at_ms(key, Self::epoch_ms());
self.url_to_nodes.entry(url).or_default().push(key);
self.bump_revision();
key
}
pub(crate) fn remove_node(&mut self, key: NodeKey) -> bool {
if let Some(node) = self.inner.remove(key) {
for address in &node.addresses {
self.remove_url_mapping(address.as_url_str(), key);
}
let node_id = node.id;
self.remove_facets_for_node(node_id);
let removed_id = node_id.to_string();
for record in &mut self.import_records {
record
.memberships
.retain(|membership| membership.node_id != removed_id);
}
self.import_records
.retain(|record| !record.memberships.is_empty());
self.bump_revision();
true
} else {
false
}
}
pub(crate) fn update_node_url(&mut self, key: NodeKey, new_url: String) -> Option<String> {
let node = self.inner.node_mut(key)?;
let old_url = node.primary_address().as_url_str().to_string();
if cached_host_from_url(&old_url) != cached_host_from_url(&new_url) {
node.clear_image(crate::types::ImageRole::Favicon);
}
let new_primary_address = address_from_url(&new_url);
if let Some(primary) = node.addresses.first_mut() {
*primary = new_primary_address;
}
self.remove_url_mapping(&old_url, key);
self.url_to_nodes.entry(new_url).or_default().push(key);
Some(old_url)
}
pub(crate) fn navigate_node(&mut self, key: NodeKey, url: &str) {
let at_ms = Self::epoch_ms();
if let Some(id) = self.inner.node(key).map(|n| n.id) {
self.nav
.record_visit(id, url, chartulary::stemma::TransitionKind::UrlTyped, at_ms);
}
self.set_node_last_session_visited(key, self.current_session);
self.update_node_url(key, url.to_string());
}
pub(crate) fn branch_history(&mut self, child: NodeKey, parent: NodeKey) {
let (Some(child_id), Some(parent_id)) = (
self.inner.node(child).map(|n| n.id),
self.inner.node(parent).map(|n| n.id),
) else {
return;
};
self.nav.spawn(child_id, parent_id);
}
pub(crate) fn node_history_back(&mut self, key: NodeKey) -> Option<String> {
let at_ms = Self::epoch_ms();
let id = self.inner.node(key)?.id;
let url = self.nav.back(id, at_ms)?;
self.update_node_url(key, url.clone());
Some(url)
}
pub(crate) fn node_history_forward(&mut self, key: NodeKey) -> Option<String> {
let at_ms = Self::epoch_ms();
let id = self.inner.node(key)?.id;
let url = self.nav.forward(id, at_ms)?;
self.update_node_url(key, url.clone());
Some(url)
}
pub fn node_can_back(&self, key: NodeKey) -> bool {
self.inner
.node(key)
.is_some_and(|n| self.nav.can_back(n.id))
}
pub fn node_can_forward(&self, key: NodeKey) -> bool {
self.inner
.node(key)
.is_some_and(|n| self.nav.can_forward(n.id))
}
pub fn node_current_url(&self, key: NodeKey) -> Option<String> {
let id = self.inner.node(key)?.id;
self.nav.current_url(id)
}
pub fn node_history_projection(&self, key: NodeKey) -> NodeHistoryProjection {
match self.inner.node(key) {
Some(node) => self.nav.projection(node.id),
None => NodeHistoryProjection {
entries: Vec::new(),
current_index: 0,
},
}
}
pub fn node_history_branch_projection(&self, key: NodeKey) -> NodeHistoryBranchProjection {
self.inner
.node(key)
.map(|node| self.nav.branch_projection(node.id))
.unwrap_or_default()
}
pub fn node_history_semantic_summary(&self, key: NodeKey) -> NodeHistorySemanticSummary {
self.inner
.node(key)
.map(|node| self.nav.semantic_summary(node.id))
.unwrap_or_default()
}
pub fn recent_visited(&self, limit: usize) -> Vec<RecentVisit> {
self.nav.recent_visited(limit)
}
fn epoch_ms() -> u64 {
crate::time::unix_epoch_millis()
}
}
pub mod edge_ops;
pub mod query;
pub mod display;
pub mod snapshot;
#[cfg(test)]
mod tests;