wasm4pm 26.7.1

High-performance process mining algorithms in WebAssembly for JavaScript/TypeScript
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Statistical analysis functions for event logs stored in the handle cache.
//!
//! Functions in this module operate on handles returned by `load_eventlog_from_xes()`
//! and return JSON strings that must be `JSON.parse()`d on the JS side.
//!
//! ## Available analyses
//!
//! | Function | Output |
//! |---|---|
//! | `analyze_event_statistics` | `{ total_cases, total_events, avg_events_per_case }` |
//! | `analyze_case_duration` | `{ min_ms, max_ms, mean_ms, median_ms, p95_ms }` |
//! | `analyze_dotted_chart` | `{ events[] }` for timeline visualization |

use crate::error::{codes, wasm_err};
use crate::state::{get_or_init_state, StoredObject};
use crate::utilities::to_js_str;
use crate::{Data, Median}; // Conditional import: statrs or hand_rolled_stats
use serde_json::json;
use wasm_bindgen::prelude::*;

/// Perform dotted chart analysis on an EventLog
#[wasm_bindgen]
pub fn analyze_dotted_chart(eventlog_handle: &str) -> Result<JsValue, JsValue> {
    get_or_init_state().with_event_log(eventlog_handle, |log| {
        let mut data = Vec::new();
        let mut total_events = 0;

        for (case_idx, trace) in log.traces.iter().enumerate() {
            let case_events = trace.events.len();
            total_events += case_events;

            data.push(json!({
                "case_id": case_idx,
                "event_count": case_events,
            }));
        }

        to_js_str(&json!({
            "type": "dotted_chart",
            "case_count": log.traces.len(),
            "total_events": total_events,
            "cases": data
        }))
    })
}

/// Get event statistics from an EventLog
#[wasm_bindgen]
pub fn analyze_event_statistics(eventlog_handle: &str) -> Result<JsValue, JsValue> {
    get_or_init_state().with_event_log(eventlog_handle, |log| {
        let total_events = log.event_count();
        let total_cases = log.case_count();

        let stats = json!({
            "total_events": total_events,
            "total_cases": total_cases,
            "avg_events_per_case": if total_cases > 0 {
                total_events as f64 / total_cases as f64
            } else {
                0.0
            },
        });

        to_js_str(&stats)
    })
}

/// Get object statistics from an OCEL
#[wasm_bindgen]
pub fn analyze_ocel_statistics(ocel_handle: &str) -> Result<JsValue, JsValue> {
    get_or_init_state().with_ocel(ocel_handle, |ocel| {
        let stats = json!({
            "total_events": ocel.event_count(),
            "total_objects": ocel.object_count(),
        });

        to_js_str(&stats)
    })
}

/// Analyze case duration from an EventLog
#[wasm_bindgen]
pub fn analyze_case_duration(eventlog_handle: &str) -> Result<JsValue, JsValue> {
    get_or_init_state().with_event_log(eventlog_handle, |log| {
        let mut event_counts: Vec<usize> = log.traces.iter().map(|t| t.events.len()).collect();

        let stats = if !event_counts.is_empty() {
            event_counts.sort_unstable();
            let sum: usize = event_counts.iter().sum();
            let avg = sum as f64 / event_counts.len() as f64;

            // Use statrs for proper median calculation
            let counts_f64: Vec<f64> = event_counts.iter().map(|&x| x as f64).collect();
            let data = Data::new(counts_f64);
            let median = data.median() as usize;

            json!({
                "case_count": event_counts.len(),
                "average_events_per_case": avg,
                "median_events_per_case": median,
                "min_events_per_case": event_counts[0],
                "max_events_per_case": event_counts[event_counts.len() - 1],
            })
        } else {
            json!({
                "case_count": 0,
                "average_events_per_case": 0,
                "median_events_per_case": 0,
                "min_events_per_case": 0,
                "max_events_per_case": 0,
            })
        };

        to_js_str(&stats)
    })
}

/// Get list of available analysis functions
#[wasm_bindgen]
pub fn available_analysis_functions() -> String {
    json!({
        "functions": [
            {
                "name": "dotted_chart",
                "description": "Dotted chart analysis for EventLogs",
                "input_type": "EventLog"
            },
            {
                "name": "event_statistics",
                "description": "Event frequency and activity statistics",
                "input_type": "EventLog"
            },
            {
                "name": "ocel_statistics",
                "description": "Object-centric statistics from OCEL",
                "input_type": "OCEL"
            },
            {
                "name": "case_duration",
                "description": "Case duration analysis",
                "input_type": "EventLog"
            }
        ]
    })
    .to_string()
}