chore: inline crate clash-verge-types to module for better maintenance (#6142)

src-tauri/src/config/config.rs

@@ -1,6 +1,6 @@
 use super::{IClashTemp, IProfiles, IVerge};
 use crate::{
-    config::{PrfItem, profiles_append_item_safe},
+    config::{PrfItem, profiles_append_item_safe, runtime::IRuntime},
     constants::{files, timing},
     core::{
         CoreManager,
@@ -16,7 +16,6 @@ use anyhow::{Result, anyhow};
 use backoff::{Error as BackoffError, ExponentialBackoff};
 use clash_verge_draft::Draft;
 use clash_verge_logging::{Type, logging, logging_error};
-use clash_verge_types::runtime::IRuntime;
 use smartstring::alias::String;
 use std::path::PathBuf;
 use tauri_plugin_clash_verge_sysinfo::is_current_app_handle_admin;

src-tauri/src/config/mod.rs

@@ -4,6 +4,7 @@ mod config;
 mod encrypt;
 mod prfitem;
 pub mod profiles;
+pub mod runtime;
 mod verge;
 
 pub use self::{clash::*, config::*, encrypt::*, prfitem::*, profiles::*, verge::*};

src-tauri/src/config/runtime.rs

@@ -0,0 +1,140 @@
+use serde_yaml_ng::{Mapping, Value};
+use smartstring::alias::String;
+use std::collections::{HashMap, HashSet};
+
+use crate::enhance::field::use_keys;
+
+const PATCH_CONFIG_INNER: [&str; 4] = ["allow-lan", "ipv6", "log-level", "unified-delay"];
+
+#[derive(Default, Clone)]
+pub struct IRuntime {
+    pub config: Option<Mapping>,
+    // 记录在订阅中（包括merge和script生成的）出现过的keys
+    // 这些keys不一定都生效
+    pub exists_keys: HashSet<String>,
+    // TODO 或许可以用 FixMap 来存储以提升效率
+    pub chain_logs: HashMap<String, Vec<(String, String)>>,
+}
+
+impl IRuntime {
+    #[inline]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    // 这里只更改 allow-lan | ipv6 | log-level | tun
+    #[inline]
+    pub fn patch_config(&mut self, patch: &Mapping) {
+        let config = if let Some(config) = self.config.as_mut() {
+            config
+        } else {
+            return;
+        };
+
+        for key in PATCH_CONFIG_INNER.iter() {
+            if let Some(value) = patch.get(key) {
+                config.insert((*key).into(), value.clone());
+            }
+        }
+
+        let patch_tun = patch.get("tun");
+        if let Some(patch_tun_value) = patch_tun {
+            let mut tun = config
+                .get("tun")
+                .and_then(|val| val.as_mapping())
+                .cloned()
+                .unwrap_or_else(Mapping::new);
+
+            if let Some(patch_tun_mapping) = patch_tun_value.as_mapping() {
+                for key in use_keys(patch_tun_mapping) {
+                    if let Some(value) = patch_tun_mapping.get(key.as_str()) {
+                        tun.insert(Value::from(key.as_str()), value.clone());
+                    }
+                }
+            }
+
+            config.insert("tun".into(), Value::from(tun));
+        }
+    }
+
+    /// 更新链式代理配置
+    ///
+    /// 该函数更新 `proxies` 和 `proxy-groups` 配置，并处理链式代理的修改或(传入 None )删除。
+    ///
+    /// 配置示例：
+    ///
+    /// ```json
+    /// {
+    ///     "proxies": [
+    ///         {
+    ///             "name": "入口节点",
+    ///             "type": "xxx",
+    ///             "server": "xxx",
+    ///             "port": "xxx",
+    ///             "ports": "xxx",
+    ///             "password": "xxx",
+    ///             "skip-cert-verify": "xxx"
+    ///         },
+    ///         {
+    ///             "name": "hop_node_1_xxxx",
+    ///             "type": "xxx",
+    ///             "server": "xxx",
+    ///             "port": "xxx",
+    ///             "ports": "xxx",
+    ///             "password": "xxx",
+    ///             "skip-cert-verify": "xxx",
+    ///             "dialer-proxy": "入口节点"
+    ///         },
+    ///         {
+    ///             "name": "出口节点",
+    ///             "type": "xxx",
+    ///             "server": "xxx",
+    ///             "port": "xxx",
+    ///             "ports": "xxx",
+    ///             "password": "xxx",
+    ///             "skip-cert-verify": "xxx",
+    ///             "dialer-proxy": "hop_node_1_xxxx"
+    ///         }
+    ///     ],
+    ///     "proxy-groups": [
+    ///         {
+    ///             "name": "proxy_chain",
+    ///             "type": "select",
+    ///             "proxies": ["出口节点"]
+    ///         }
+    ///     ]
+    /// }
+    /// ```
+    #[inline]
+    pub fn update_proxy_chain_config(&mut self, proxy_chain_config: Option<Value>) {
+        let config = if let Some(config) = self.config.as_mut() {
+            config
+        } else {
+            return;
+        };
+
+        if let Some(Value::Sequence(proxies)) = config.get_mut("proxies") {
+            proxies.iter_mut().for_each(|proxy| {
+                if let Some(proxy) = proxy.as_mapping_mut()
+                    && proxy.get("dialer-proxy").is_some()
+                {
+                    proxy.remove("dialer-proxy");
+                }
+            });
+        }
+
+        if let Some(Value::Sequence(dialer_proxies)) = proxy_chain_config
+            && let Some(Value::Sequence(proxies)) = config.get_mut("proxies")
+        {
+            for (i, dialer_proxy) in dialer_proxies.iter().enumerate() {
+                if let Some(Value::Mapping(proxy)) =
+                    proxies.iter_mut().find(|proxy| proxy.get("name") == Some(dialer_proxy))
+                    && i != 0
+                    && let Some(dialer_proxy) = dialer_proxies.get(i - 1)
+                {
+                    proxy.insert("dialer-proxy".into(), dialer_proxy.to_owned());
+                }
+            }
+        }
+    }
+}

src-tauri/src/core/manager/config.rs

@@ -1,13 +1,12 @@
 use super::CoreManager;
 use crate::{
-    config::{Config, ConfigType},
+    config::{Config, ConfigType, runtime::IRuntime},
     constants::timing,
     core::{handle, validate::CoreConfigValidator},
     utils::{dirs, help},
 };
 use anyhow::{Result, anyhow};
 use clash_verge_logging::{Type, logging};
-use clash_verge_types::runtime::IRuntime;
 use smartstring::alias::String;
 use std::{collections::HashSet, path::PathBuf, time::Instant};
 use tauri_plugin_mihomo::Error as MihomoError;

src-tauri/src/enhance/field.rs

@@ -61,14 +61,11 @@ pub fn use_sort(config: Mapping) -> Mapping {
     ret
 }
 
-pub fn use_keys(config: &Mapping) -> Vec<String> {
-    config
-        .iter()
-        .filter_map(|(key, _)| key.as_str())
-        .map(|s: &str| {
-            let mut s: String = s.into();
-            s.make_ascii_lowercase();
-            s
-        })
-        .collect()
+#[inline]
+pub fn use_keys<'a>(config: &'a Mapping) -> impl Iterator<Item = String> + 'a {
+    config.iter().filter_map(|(key, _)| key.as_str()).map(|s: &str| {
+        let mut s: String = s.into();
+        s.make_ascii_lowercase();
+        s
+    })
 }

src-tauri/src/enhance/mod.rs

@@ -310,7 +310,7 @@ fn process_global_items(
     profile_name: &String,
 ) -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
     let mut result_map = HashMap::new();
-    let mut exists_keys = use_keys(&config);
+    let mut exists_keys = use_keys(&config).collect::<Vec<_>>();
 
     if let ChainType::Merge(merge) = global_merge.data {
         exists_keys.extend(use_keys(&merge));