unreal-engine-mcp-server 0.5.4 → 0.5.6

package/wasm/src/lib.rs

@@ -1,153 +0,0 @@
-//! WebAssembly module for performance-critical operations
-//! in the Unreal Engine MCP Server.
-//!
-//! This module provides optimized implementations for:
-//! - Property parsing and serialization
-//! - Transform calculations
-//! - Vector math
-//! - Asset dependency resolution
-
-mod property_parser;
-mod transform_math;
-mod dependency_resolver;
-
-pub use property_parser::PropertyParser;
-pub use transform_math::{TransformCalculator, Vector, Rotator, Transform};
-pub use dependency_resolver::DependencyResolver;
-
-// Re-export wasm-bindgen for convenience
-pub use wasm_bindgen::prelude::*;
-
-/// Initialize the WASM module
-#[wasm_bindgen(start)]
-pub fn main() {
-    // This function is called when the module is loaded
-    console_error_panic_hook::set_once();
-    web_sys::console::log_1(&"WASM module initialized".into());
-}
-
-// Provide console logging in WASM
-#[wasm_bindgen]
-extern "C" {
-    #[wasm_bindgen(js_namespace = console)]
-    fn log(s: &str);
-
-    #[wasm_bindgen(js_namespace = console)]
-    fn error(s: &str);
-
-    #[wasm_bindgen(js_namespace = console)]
-    fn warn(s: &str);
-}
-
-/// Utility functions
-#[wasm_bindgen]
-pub struct Utils;
-
-#[wasm_bindgen]
-impl Utils {
-    /// Get the current high-resolution time in milliseconds
-    #[wasm_bindgen(js_name = now)]
-    pub fn now() -> f64 {
-        web_sys::window()
-            .and_then(|w| w.performance())
-            .map(|p| p.now())
-            .unwrap_or(0.0)
-    }
-
-    /// Generate a random floating-point number between 0 and 1
-    #[wasm_bindgen(js_name = random)]
-    pub fn random() -> f64 {
-        js_sys::Math::random()
-    }
-
-    /// Clamp a number between min and max
-    #[wasm_bindgen(js_name = clamp)]
-    pub fn clamp(value: f32, min: f32, max: f32) -> f32 {
-        value.max(min).min(max)
-    }
-
-    /// Linear interpolation between two values
-    #[wasm_bindgen(js_name = lerp)]
-    pub fn lerp(a: f32, b: f32, t: f32) -> f32 {
-        a + (b - a) * t
-    }
-
-    /// Convert degrees to radians
-    #[wasm_bindgen(js_name = degToRad)]
-    pub fn deg_to_rad(degrees: f32) -> f32 {
-        degrees * std::f32::consts::PI / 180.0
-    }
-
-    /// Convert radians to degrees
-    #[wasm_bindgen(js_name = radToDeg)]
-    pub fn rad_to_deg(radians: f32) -> f32 {
-        radians * 180.0 / std::f32::consts::PI
-    }
-}
-
-/// Performance metrics for WASM operations
-#[wasm_bindgen]
-pub struct Metrics {
-    operations: Vec<OperationMetric>,
-}
-
-#[derive(Clone)]
-struct OperationMetric {
-    name: String,
-    duration_ms: f64,
-    #[allow(dead_code)]
-    timestamp: f64,
-}
-
-#[wasm_bindgen]
-impl Metrics {
-    #[wasm_bindgen(constructor)]
-    pub fn new() -> Metrics {
-        Metrics {
-            operations: Vec::new(),
-        }
-    }
-
-    /// Record an operation
-    #[wasm_bindgen(js_name = record)]
-    pub fn record(&mut self, name: String, duration_ms: f64) {
-        let timestamp = js_sys::Date::now();
-        self.operations.push(OperationMetric {
-            name,
-            duration_ms,
-            timestamp,
-        });
-    }
-
-    /// Get average duration for an operation
-    #[wasm_bindgen(js_name = averageFor)]
-    pub fn average_for(&self, name: String) -> f64 {
-        let mut total = 0.0;
-        let mut count = 0.0;
-
-        for op in &self.operations {
-            if op.name == name {
-                total += op.duration_ms;
-                count += 1.0;
-            }
-        }
-
-        if count > 0.0 {
-            total / count
-        } else {
-            0.0
-        }
-    }
-
-    /// Get total number of operations recorded
-    #[wasm_bindgen]
-    pub fn count(&self) -> u32 {
-        self.operations.len() as u32
-    }
-
-    /// Clear all metrics
-    #[wasm_bindgen]
-    pub fn clear(&mut self) {
-        self.operations.clear();
-    }
-}

package/wasm/src/property_parser.rs

@@ -1,271 +0,0 @@
-//! Property parsing and serialization module
-//!
-//! This module provides efficient parsing and serialization of
-//! Unreal Engine property data structures.
-
-use serde::{Serialize, Deserialize};
-use serde_json::{Value, Map};
-use wasm_bindgen::prelude::*;
-use serde_wasm_bindgen as swb;
-
-/// A parsed property with metadata
-#[derive(Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct ParsedProperty {
-    pub name: String,
-    pub value: Value,
-    pub property_type: String,
-    pub is_array: bool,
-    pub nested_properties: Option<Vec<ParsedProperty>>,
-}
-
-/// Result of parsing properties
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ParseResult {
-    pub properties: Vec<ParsedProperty>,
-    pub total_count: usize,
-    pub parse_time_ms: f64,
-}
-
-#[wasm_bindgen]
-pub struct PropertyParser {
-    /// Maximum nesting depth to prevent stack overflow
-    max_depth: usize,
-}
-
-#[wasm_bindgen]
-impl PropertyParser {
-    /// Create a new PropertyParser with default max depth (100)
-    #[wasm_bindgen(constructor)]
-    pub fn new() -> PropertyParser {
-        console_error_panic_hook::set_once();
-        PropertyParser { max_depth: 100 }
-    }
-
-    /// Create a PropertyParser with custom max depth
-    #[wasm_bindgen(js_name = withMaxDepth)]
-    pub fn with_max_depth(max_depth: usize) -> PropertyParser {
-        console_error_panic_hook::set_once();
-        PropertyParser { max_depth }
-    }
-
-    /// Parse JSON string into structured properties
-    #[wasm_bindgen]
-    pub fn parse_properties(&self, json_str: &str, max_depth: Option<usize>) -> Result<JsValue, JsValue> {
-        let start = js_sys::Date::now();
-
-        let value: Value = serde_json::from_str(json_str)
-            .map_err(|e| JsValue::from_str(&format!("JSON parse error: {}", e)))?;
-
-        let depth_limit = max_depth.unwrap_or(self.max_depth);
-        let properties = self.parse_value(&value, "root", depth_limit)?;
-
-        let parse_time = js_sys::Date::now() - start;
-
-        let total_count = self.count_properties(&properties);
-
-        let result = ParseResult {
-            properties,
-            total_count,
-            parse_time_ms: parse_time,
-        };
-
-        let js_value = swb::to_value(&result)
-            .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))?;
-        Ok(js_value)
-    }
-
-    /// Serialize properties back to JSON
-    #[wasm_bindgen]
-    pub fn serialize_properties(&self, properties_js: &JsValue) -> Result<String, JsValue> {
-        let properties: Vec<ParsedProperty> = swb::from_value(properties_js.clone())
-            .map_err(|e| JsValue::from_str(&format!("Deserialize error: {}", e)))?;
-
-        let value = self.properties_to_value(&properties);
-        serde_json::to_string_pretty(&value)
-            .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))
-    }
-
-    /// Extract all property names from JSON
-    #[wasm_bindgen]
-    pub fn extract_property_names(&self, json_str: &str) -> Result<JsValue, JsValue> {
-        let value: Value = serde_json::from_str(json_str)
-            .map_err(|e| JsValue::from_str(&format!("JSON parse error: {}", e)))?;
-
-        let mut names = Vec::new();
-        self.extract_names(&value, &mut names);
-
-        let js_value = swb::to_value(&names)
-            .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))?;
-        Ok(js_value)
-    }
-
-    /// Get property type from JSON value
-    #[wasm_bindgen(js_name = getPropertyType)]
-    pub fn get_property_type(&self, json_str: &str) -> Result<String, JsValue> {
-        let value: Value = serde_json::from_str(json_str)
-            .map_err(|e| JsValue::from_str(&format!("JSON parse error: {}", e)))?;
-
-        let prop_type = self.infer_property_type(&value);
-        Ok(prop_type)
-    }
-}
-
-impl PropertyParser {
-    fn parse_value(&self, value: &Value, name: &str, depth: usize) -> Result<Vec<ParsedProperty>, JsValue> {
-        if depth == 0 {
-            return Err(JsValue::from_str("Maximum nesting depth exceeded"));
-        }
-
-        let prop_type = self.infer_property_type(value);
-
-        let mut properties = Vec::new();
-
-        match value {
-            Value::Null => {
-                properties.push(ParsedProperty {
-                    name: name.to_string(),
-                    value: value.clone(),
-                    property_type: prop_type,
-                    is_array: false,
-                    nested_properties: None,
-                });
-            }
-            Value::Bool(_) | Value::Number(_) | Value::String(_) => {
-                properties.push(ParsedProperty {
-                    name: name.to_string(),
-                    value: value.clone(),
-                    property_type: prop_type,
-                    is_array: false,
-                    nested_properties: None,
-                });
-            }
-            Value::Array(arr) => {
-                let mut nested = Vec::new();
-                for (i, item) in arr.iter().enumerate() {
-                    let item_name = format!("{}[{}]", name, i);
-                    let mut item_properties = self.parse_value(item, &item_name, depth - 1)?;
-                    nested.append(&mut item_properties);
-                }
-
-                properties.push(ParsedProperty {
-                    name: name.to_string(),
-                    value: value.clone(),
-                    property_type: prop_type,
-                    is_array: true,
-                    nested_properties: Some(nested),
-                });
-            }
-            Value::Object(obj) => {
-                let mut nested = Vec::new();
-                for (key, val) in obj {
-                    let nested_properties = self.parse_value(val, key, depth - 1)?;
-                    nested.extend(nested_properties);
-                }
-
-                properties.push(ParsedProperty {
-                    name: name.to_string(),
-                    value: value.clone(),
-                    property_type: prop_type,
-                    is_array: false,
-                    nested_properties: Some(nested),
-                });
-            }
-        }
-
-        Ok(properties)
-    }
-
-    fn infer_property_type(&self, value: &Value) -> String {
-        match value {
-            Value::Null => "null".to_string(),
-            Value::Bool(_) => "boolean".to_string(),
-            Value::Number(n) => {
-                if n.is_f64() {
-                    "float".to_string()
-                } else {
-                    "integer".to_string()
-                }
-            }
-            Value::String(_) => "string".to_string(),
-            Value::Array(_) => "array".to_string(),
-            Value::Object(_) => "object".to_string(),
-        }
-    }
-
-    fn extract_names(&self, value: &Value, names: &mut Vec<String>) {
-        match value {
-            Value::Object(obj) => {
-                for (key, val) in obj {
-                    names.push(key.clone());
-                    self.extract_names(val, names);
-                }
-            }
-            Value::Array(arr) => {
-                for item in arr {
-                    self.extract_names(item, names);
-                }
-            }
-            _ => {}
-        }
-    }
-
-    fn count_properties(&self, properties: &[ParsedProperty]) -> usize {
-        let mut count = properties.len();
-        for prop in properties {
-            if let Some(nested) = &prop.nested_properties {
-                count += self.count_properties(nested);
-            }
-        }
-        count
-    }
-
-    fn properties_to_value(&self, properties: &[ParsedProperty]) -> Value {
-        // This is a simplified conversion - in practice, you'd want more sophisticated handling
-        let mut map = Map::new();
-
-        for prop in properties {
-            let val = if let Some(nested) = &prop.nested_properties {
-                if nested.is_empty() {
-                    prop.value.clone()
-                } else {
-                    self.nested_to_value(nested)
-                }
-            } else {
-                prop.value.clone()
-            };
-            map.insert(prop.name.clone(), val);
-        }
-
-        Value::Object(map)
-    }
-
-    fn nested_to_value(&self, properties: &[ParsedProperty]) -> Value {
-        if properties.is_empty() {
-            return Value::Null;
-        }
-
-        if properties.len() == 1 {
-            let prop = &properties[0];
-            if let Some(nested) = &prop.nested_properties {
-                let mut map = Map::new();
-                map.insert(prop.name.clone(), self.nested_to_value(nested));
-                Value::Object(map)
-            } else {
-                prop.value.clone()
-            }
-        } else {
-            let mut map = Map::new();
-            for prop in properties {
-                let val = if let Some(nested) = &prop.nested_properties {
-                    self.nested_to_value(nested)
-                } else {
-                    prop.value.clone()
-                };
-                map.insert(prop.name.clone(), val);
-            }
-            Value::Object(map)
-        }
-    }
-}