nmp-threading 1.0.0-rc.1

Reply-convention-agnostic timeline grouping algorithm. Owns ThreadPointer / ParentResolver / ModulePolicy / TimelineBlock / Grouper, consumed by per-NIP wrapper view modules (NIP-10 in nmp-nip01). No app nouns, no kind semantics.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! Kind-blind resolver for marked/positional `e` tag reply/root grammar.
//!
//! The resolver intentionally ignores event kind. It interprets the same
//! marked/positional `e` tag shape for any caller-supplied event scope, so
//! NIP-29 group timelines, note feeds, or other scoped event streams can reuse
//! one threading read model without app-side tag parsing.

use nmp_core::substrate::KernelEvent;

use crate::{ParentResolver, ThreadPointer};

/// [`ParentResolver`] over raw `e` tags, independent of event kind.
#[derive(Clone, Copy, Debug, Default)]
pub struct EtagThreadResolver;

impl ParentResolver for EtagThreadResolver {
    fn parent(&self, event: &KernelEvent) -> Option<ThreadPointer> {
        parse_e_refs(&event.tags)
            .reply
            .map(|r| ThreadPointer::Event {
                id: r.id,
                relay: r.relay,
                kind: None,
            })
    }

    fn root(&self, event: &KernelEvent) -> Option<ThreadPointer> {
        parse_e_refs(&event.tags)
            .root
            .map(|r| ThreadPointer::Event {
                id: r.id,
                relay: r.relay,
                kind: None,
            })
    }

    fn parent_author(&self, event: &KernelEvent) -> Option<String> {
        event
            .tags
            .iter()
            .find(|tag| tag.first().map(String::as_str) == Some("p"))
            .and_then(|tag| tag.get(1).cloned())
    }
}

#[derive(Clone)]
struct ERef {
    id: String,
    relay: Option<String>,
    marker: Option<String>,
}

#[derive(Default)]
struct ERefs {
    root: Option<ERef>,
    reply: Option<ERef>,
}

fn parse_e_refs(tags: &[Vec<String>]) -> ERefs {
    let e_tags: Vec<&Vec<String>> = tags
        .iter()
        .filter(|tag| tag.first().map(String::as_str) == Some("e"))
        .collect();
    let has_marker = e_tags.iter().any(|tag| {
        matches!(
            tag.get(3).map(String::as_str),
            Some("root" | "reply" | "mention")
        )
    });

    if has_marker {
        let mut refs = ERefs::default();
        for tag in e_tags {
            let Some(eref) = e_ref(tag) else { continue };
            match eref.marker.as_deref() {
                Some("root") if refs.root.is_none() => refs.root = Some(eref),
                Some("reply") if refs.reply.is_none() => refs.reply = Some(eref),
                _ => {}
            }
        }
        if refs.reply.is_none() {
            refs.reply = refs.root.clone();
        }
        return refs;
    }

    let resolved: Vec<ERef> = e_tags.into_iter().filter_map(|tag| e_ref(tag)).collect();
    match resolved.len() {
        0 => ERefs::default(),
        1 => ERefs {
            root: Some(resolved[0].clone()),
            reply: Some(resolved[0].clone()),
        },
        n => ERefs {
            root: Some(resolved[0].clone()),
            reply: Some(resolved[n - 1].clone()),
        },
    }
}

fn e_ref(tag: &[String]) -> Option<ERef> {
    let id = tag.get(1)?.clone();
    if id.is_empty() {
        return None;
    }
    Some(ERef {
        id,
        relay: tag.get(2).filter(|s| !s.is_empty()).cloned(),
        marker: tag.get(3).filter(|s| !s.is_empty()).cloned(),
    })
}