titanpl 6.0.0 → 7.0.0

package/packages/core-source/native/src/storage_impl.rs

@@ -0,0 +1,73 @@
+use std::collections::HashMap;
+use std::sync::{OnceLock, RwLock};
+
+
+static STORAGE: OnceLock<RwLock<HashMap<String, String>>> = OnceLock::new();
+static SESSIONS: OnceLock<RwLock<HashMap<String, String>>> = OnceLock::new();
+
+fn get_storage() -> &'static RwLock<HashMap<String, String>> {
+    STORAGE.get_or_init(|| RwLock::new(HashMap::new()))
+}
+
+fn get_sessions() -> &'static RwLock<HashMap<String, String>> {
+    SESSIONS.get_or_init(|| RwLock::new(HashMap::new()))
+}
+
+// --- Local Storage ---
+
+pub fn ls_get(key: &str) -> Option<String> {
+    let map = get_storage().read().ok()?;
+    map.get(key).cloned()
+}
+
+pub fn ls_set(key: &str, value: &str) -> Result<(), String> {
+    let mut map = get_storage().write().map_err(|_| "Storage write lock poisoned".to_string())?;
+    map.insert(key.to_string(), value.to_string());
+    Ok(())
+}
+
+pub fn ls_remove(key: &str) -> Result<(), String> {
+    let mut map = get_storage().write().map_err(|_| "Storage write lock poisoned".to_string())?;
+    map.remove(key);
+    Ok(())
+}
+
+pub fn ls_clear() -> Result<(), String> {
+    let mut map = get_storage().write().map_err(|_| "Storage write lock poisoned".to_string())?;
+    map.clear();
+    Ok(())
+}
+
+pub fn ls_keys() -> Result<Vec<String>, String> {
+    let map = get_storage().read().map_err(|_| "Storage read lock poisoned".to_string())?;
+    Ok(map.keys().cloned().collect())
+}
+
+// --- Sessions ---
+
+pub fn session_set(session_id: &str, key: &str, value: &str) -> Result<(), String> {
+    let mut map = get_sessions().write().map_err(|_| "Session write lock poisoned".to_string())?;
+    let comp_key = format!("{}:{}", session_id, key);
+    map.insert(comp_key, value.to_string());
+    Ok(())
+}
+
+pub fn session_get(session_id: &str, key: &str) -> Option<String> {
+    let map = get_sessions().read().ok()?;
+    let comp_key = format!("{}:{}", session_id, key);
+    map.get(&comp_key).cloned()
+}
+
+pub fn session_delete(session_id: &str, key: &str) -> Result<(), String> {
+    let mut map = get_sessions().write().map_err(|_| "Session write lock poisoned".to_string())?;
+    let comp_key = format!("{}:{}", session_id, key);
+    map.remove(&comp_key);
+    Ok(())
+}
+
+pub fn session_clear(session_id: &str) -> Result<(), String> {
+    let mut map = get_sessions().write().map_err(|_| "Session write lock poisoned".to_string())?;
+    let prefix = format!("{}:", session_id);
+    map.retain(|k, _| !k.starts_with(&prefix));
+    Ok(())
+}

package/packages/core-source/native/src/v8_impl.rs

@@ -0,0 +1,93 @@
+use v8;
+use v8::ValueSerializerHelper;
+use v8::ValueDeserializerHelper;
+
+struct TitanValueSerializerDelegate;
+impl v8::ValueSerializerImpl for TitanValueSerializerDelegate {
+    fn throw_data_clone_error<'s>(
+        &self,
+        scope: &mut v8::HandleScope<'s>,
+        message: v8::Local<'s, v8::String>,
+    ) {
+        let error = v8::Exception::error(scope, message);
+        scope.throw_exception(error);
+    }
+}
+
+struct TitanValueDeserializerDelegate;
+impl v8::ValueDeserializerImpl for TitanValueDeserializerDelegate {}
+
+pub fn native_serialize(
+    scope: &mut v8::HandleScope,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue,
+) {
+    let value = args.get(0);
+    let context = scope.get_current_context();
+    
+    // Create serializer with delegate
+    let mut serializer = v8::ValueSerializer::new(scope, Box::new(TitanValueSerializerDelegate));
+    serializer.write_header();
+    
+    // Serialize
+    match serializer.write_value(context, value) {
+        Some(true) => {
+            let raw_bytes = serializer.release();
+            
+            // Generate Uint8Array
+            let len = raw_bytes.len();
+            let unique_bs = v8::ArrayBuffer::new_backing_store_from_boxed_slice(raw_bytes.into_boxed_slice());
+            let shared_bs = unique_bs.make_shared();
+            let array_buffer = v8::ArrayBuffer::with_backing_store(scope, &shared_bs);
+            
+            if let Some(uint8) = v8::Uint8Array::new(scope, array_buffer, 0, len) {
+                retval.set(uint8.into());
+            }
+        },
+        _ => {}
+    }
+}
+
+pub fn native_deserialize(
+    scope: &mut v8::HandleScope,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue,
+) {
+    // Input: Uint8Array
+    let arg0 = args.get(0);
+    if !arg0.is_uint8_array() {
+         let msg = v8::String::new(scope, "Expected Uint8Array").unwrap();
+         let error = v8::Exception::type_error(scope, msg);
+         scope.throw_exception(error);
+         return;
+    }
+
+    let uint8 = v8::Local::<v8::Uint8Array>::try_from(arg0).unwrap();
+    let len = uint8.byte_length();
+    
+    // Copy bytes to vector for deserializer
+    let mut data = vec![0u8; len];
+    uint8.copy_contents(&mut data);
+
+    let context = scope.get_current_context();
+    let deserializer = v8::ValueDeserializer::new(scope, Box::new(TitanValueDeserializerDelegate), &data);
+    
+    // Read header
+    if let Some(true) = deserializer.read_header(context) {
+        // Read value
+        if let Some(value) = deserializer.read_value(context) {
+            retval.set(value);
+        } else {
+             // Invalid value format
+             let msg = v8::String::new(scope, "Failed to deserialize value").unwrap();
+             let error = v8::Exception::error(scope, msg);
+             scope.throw_exception(error);
+        }
+    } else {
+        // Invalid header
+         let msg = v8::String::new(scope, "Invalid serialization header").unwrap();
+         let error = v8::Exception::error(scope, msg);
+         scope.throw_exception(error);
+    }
+}
+