feat: Patch for windows aarch64

patches/support-windows-aarch64.patch

@@ -0,0 +1,195 @@
+From 8b085aea2f11e64f433244eda092c178a2bb50bc Mon Sep 17 00:00:00 2001
+From: MystiPanda <mystipanda@proton.me>
+Date: Sun, 10 Dec 2023 19:47:45 +0800
+Subject: [PATCH] feat: Support windows aarch64
+
+---
+ .gitmodules                     |   3 +
+ src-tauri/Cargo.toml            |   2 +-
+ src-tauri/quick-rs              |   1 +
+ src-tauri/src/enhance/script.rs | 130 +++++++++++++++++++-------------
+ 4 files changed, 81 insertions(+), 55 deletions(-)
+ create mode 100644 .gitmodules
+ create mode 160000 src-tauri/quick-rs
+
+diff --git a/.gitmodules b/.gitmodules
+new file mode 100644
+index 0000000..2eda7e4
+--- /dev/null
++++ b/.gitmodules
+@@ -0,0 +1,3 @@
++[submodule "src-tauri/quick-rs"]
++	path = src-tauri/quick-rs
++	url = https://github.com/clash-verge-rev/quick-rs.git
+diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
+index 4c6dde5..5fd9ad8 100644
+--- a/src-tauri/Cargo.toml
++++ b/src-tauri/Cargo.toml
+@@ -25,7 +25,6 @@ log4rs = "1"
+ nanoid = "0.4"
+ chrono = "0.4"
+ sysinfo = "0.29"
+-rquickjs = "0.4"
+ serde_json = "1.0"
+ serde_yaml = "0.9"
+ auto-launch = "0.5"
+@@ -34,6 +33,7 @@ port_scanner = "0.1.5"
+ delay_timer = "0.11"
+ parking_lot = "0.12"
+ percent-encoding = "2.3.1"
++quick-rs = { path = "quick-rs" }
+ window-shadows = { version = "0.2" }
+ tokio = { version = "1", features = ["full"] }
+ serde = { version = "1.0", features = ["derive"] }
+diff --git a/src-tauri/quick-rs b/src-tauri/quick-rs
+new file mode 160000
+index 0000000..78277c4
+--- /dev/null
++++ b/src-tauri/quick-rs
+@@ -0,0 +1 @@
++Subproject commit 78277c4509c64f18c0fc5c9f2b84671de7c83343
+diff --git a/src-tauri/src/enhance/script.rs b/src-tauri/src/enhance/script.rs
+index 6c207d9..d47dc33 100644
+--- a/src-tauri/src/enhance/script.rs
++++ b/src-tauri/src/enhance/script.rs
+@@ -3,61 +3,83 @@ use anyhow::Result;
+ use serde_yaml::Mapping;
+ 
+ pub fn use_script(script: String, config: Mapping) -> Result<(Mapping, Vec<(String, String)>)> {
+-    use rquickjs::{function::Func, Context, Runtime};
+-    use std::sync::{Arc, Mutex};
+-
+-    let runtime = Runtime::new().unwrap();
+-    let context = Context::full(&runtime).unwrap();
+-    let outputs = Arc::new(Mutex::new(vec![]));
+-
+-    let copy_outputs = outputs.clone();
+-    let result = context.with(|ctx| -> Result<Mapping> {
+-        ctx.globals().set(
+-            "__verge_log__",
+-            Func::from(move |level: String, data: String| {
+-                let mut out = copy_outputs.lock().unwrap();
+-                out.push((level, data));
+-            }),
+-        )?;
+-
+-        ctx.eval(
+-            r#"var console = Object.freeze({
+-        log(data){__verge_log__("log",JSON.stringify(data))}, 
+-        info(data){__verge_log__("info",JSON.stringify(data))}, 
+-        error(data){__verge_log__("error",JSON.stringify(data))},
+-        debug(data){__verge_log__("debug",JSON.stringify(data))},
+-      });"#,
+-        )?;
+-
+-        let config = use_lowercase(config.clone());
+-        let config_str = serde_json::to_string(&config)?;
+-
+-        let code = format!(
+-            r#"try{{
++    use quick_rs::{context::Context, function::Function, module::Module, runtime::Runtime};
++
++    let config = use_lowercase(config.clone());
++    let config_str = serde_json::to_string(&config)?;
++
++    let runtime = Runtime::new();
++    let context = Context::from(&runtime);
++
++    let code = format!(
++        r#"
++        let output = [];
++
++        function __verge_log__(type, data) {{
++          output.push([type, data]);
++        }}
++
++        var console = Object.freeze({{
++          log(data) {{ __verge_log__("log", JSON.stringify(data)) }},
++          info(data) {{ __verge_log__("info", JSON.stringify(data)) }},
++          error(data) {{ __verge_log__("error", JSON.stringify(data)) }},
++          debug(data) {{ __verge_log__("debug", JSON.stringify(data)) }},
++        }});
++
+         {script};
+-        JSON.stringify(main({config_str})||'')
+-      }} catch(err) {{
+-        `__error_flag__ ${{err.toString()}}`
+-      }}"#
+-        );
+-        let result: String = ctx.eval(code.as_str())?;
+-        if result.starts_with("__error_flag__") {
+-            anyhow::bail!(result[15..].to_owned());
+-        }
+-        if result == "\"\"" {
+-            anyhow::bail!("main function should return object");
+-        }
+-        return Ok(serde_json::from_str::<Mapping>(result.as_str())?);
+-    });
+-
+-    let mut out = outputs.lock().unwrap();
+-    match result {
+-        Ok(config) => Ok((use_lowercase(config), out.to_vec())),
+-        Err(err) => {
+-            out.push(("exception".into(), err.to_string()));
+-            Ok((config, out.to_vec()))
+-        }
+-    }
++
++        export function _main(){{
++          try{{
++            let result = JSON.stringify(main({config_str})||"");
++            return JSON.stringify({{result, output}});
++          }} catch(err) {{
++            output.push(["exception", err.toString()]);
++            return JSON.stringify({{result: "__error__", output}});
++          }}
++        }}
++        "#
++    );
++    let value = context.eval_module(&code, "_main")?;
++    let module = Module::new(value)?;
++    let value = module.get("_main")?;
++    let function = Function::new(value)?;
++    let value = function.call(vec![])?;
++    let result = serde_json::from_str::<serde_json::Value>(&value.to_string()?)?;
++    result
++        .as_object()
++        .map(|obj| {
++            let result = obj.get("result").unwrap().as_str().unwrap();
++            let output = obj.get("output").unwrap();
++
++            let mut out = output
++                .as_array()
++                .unwrap()
++                .iter()
++                .map(|item| {
++                    let item = item.as_array().unwrap();
++                    (
++                        item[0].as_str().unwrap().into(),
++                        item[1].as_str().unwrap().into(),
++                    )
++                })
++                .collect::<Vec<_>>();
++            if result.is_empty() {
++                anyhow::bail!("main function should return object");
++            }
++            if result == "__error__" {
++                return Ok((config, out.to_vec()));
++            }
++            let result = serde_json::from_str::<Mapping>(result);
++
++            match result {
++                Ok(config) => Ok((use_lowercase(config), out.to_vec())),
++                Err(err) => {
++                    out.push(("exception".into(), err.to_string()));
++                    Ok((config, out.to_vec()))
++                }
++            }
++        })
++        .unwrap_or_else(|| anyhow::bail!("Unknown result"))
+ }
+ 
+ #[test]
+-- 
+2.43.0.windows.1
+