Merge branch 'dev'

Author: nomnomab

src-tauri/src/editor.rs

@@ -141,7 +141,7 @@ pub fn find_editor_installs(app_state: &tauri::State<AppState>) -> anyhow::Resul
     Ok(editors)
 }
 
-pub fn open(editor_version: String, arguments: Vec<String>, app_state: &tauri::State<AppState>) -> anyhow::Result<(), errors::AnyError> {
+pub fn open(editor_version: String, arguments: Vec<String>, app_state: &tauri::State<AppState>, wait: bool) -> anyhow::Result<(), errors::AnyError> {
     let editor = app_state.editors.lock()
         .map_err(|_| errors::str_error("Failed to get editors. Is it locked?"))?
         .iter()
@@ -151,9 +151,15 @@ pub fn open(editor_version: String, arguments: Vec<String>, app_state: &tauri::S
 
     let exe_path = editor.exe_path;
 
-    std::process::Command::new(&exe_path)
-        .args(arguments)
-        .spawn()?;
+    if wait {
+        std::process::Command::new(&exe_path)
+            .args(arguments)
+            .output()?;
+    } else {
+        std::process::Command::new(&exe_path)
+            .args(arguments)
+            .spawn()?;
+    }
 
     Ok(())
 }

src-tauri/src/generate.rs

@@ -2,15 +2,16 @@ use std::{collections::HashMap, path::PathBuf};
 
 use flate2::{read::GzDecoder, write::GzEncoder};
 
-use crate::{app::{self, AppState}, editor::UnityEditorInstall, errors, io_utils, package::{self, MinimalPackage}, template::SurfaceTemplate};
+use crate::{app::{self, AppState}, editor::{self, UnityEditorInstall}, errors, io_utils, package::{self, MinimalPackage}, template::SurfaceTemplate};
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TemplateInfoForGeneration {
   template: Option<SurfaceTemplate>,
   editor_version: UnityEditorInstall,
   packages: Vec<MinimalPackage>,
-  selected_files: Vec<PathBuf>
+  selected_files: Vec<PathBuf>,
+  is_empty: bool
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -31,39 +32,74 @@ pub struct NewTemplateInfo {
 }
 
 // generate a new project from a template + info
-pub fn generate_project(app: &tauri::AppHandle, project_info: &ProjectInfoForGeneration, template_info: &TemplateInfoForGeneration) -> Result<PathBuf, errors::AnyError> {
+pub fn generate_project(app: &tauri::AppHandle, app_state: &tauri::State<'_, AppState>, project_info: &ProjectInfoForGeneration, template_info: &TemplateInfoForGeneration) -> Result<PathBuf, errors::AnyError> {
   let package_cache_dir_out = &project_info.path.join(project_info.name.clone());
   if package_cache_dir_out.exists() {
     return Err(errors::str_error(format!("Project already exists at {}", package_cache_dir_out.display()).as_str()));
   }
-  
+
   let package_cache_dir = io_utils::get_cache_appended_dir(app, "new_project_package");
-  unpack_package_into_cache(&package_cache_dir, &template_info)?;
-  modify_package_json(&package_cache_dir, &template_info.packages, &package_cache_dir_out)?;
+  if template_info.is_empty {
+    // make a new project
+    // copy entire project over
+    // modify manifest
+
+    let editor_version = &template_info.editor_version.version;
+    let package_cache_dir_out_str = package_cache_dir_out
+      .to_str()
+      .ok_or(errors::str_error("Failed to convert path to string"))?
+      .to_string();
+    // let tmp_path = package_cache_dir
+    //   .join("project")
+    //   .join("ProjectData~")
+    //   .to_str()
+    //   .ok_or(errors::str_error("Failed to convert path to string"))?
+    //   .to_string();
+    let args = vec!["-createProject".to_string(), package_cache_dir_out_str, "-quit".to_string()];
+    editor::open(editor_version.clone(), args, &app_state, true)?;
+
+    let packages_dir = package_cache_dir_out
+      .join("Packages");
+    modify_package_json(&packages_dir, &template_info.packages, &package_cache_dir_out)?;
+  } else {
+    let packages_dir = package_cache_dir
+      .join("package")
+      .join("ProjectData~")
+      .join("Packages");
+    
+    unpack_package_into_cache(&package_cache_dir, &template_info)?;
+    modify_package_json(&packages_dir, &template_info.packages, &package_cache_dir_out)?;
+  }
 
   // create project directory
-  std::fs::create_dir(&package_cache_dir_out)?;
-  std::fs::create_dir(&package_cache_dir_out.join("Assets"))?;
+  std::fs::create_dir_all(&package_cache_dir_out.join("Assets"))?;
+  std::fs::create_dir_all(&package_cache_dir_out.join("ProjectSettings"))?;
+  std::fs::create_dir_all(&package_cache_dir_out.join("Packages"))?;
 
   // copy contents from ProjectData~ to output
   let project_data_root = PathBuf::from("package").join("ProjectData~");
-  for file in template_info.selected_files.iter().filter(|x| x.starts_with(&project_data_root)) {
-    let trimmed_file = file.strip_prefix(&project_data_root)
-      .map_err(|_| errors::str_error("Failed to strip prefix"))?;
-    let from = package_cache_dir.join(file);
-    let dest = package_cache_dir_out.join(trimmed_file);
-    println!("Copying {} to {}", from.display(), dest.display());
-    
-    if dest.extension().is_none() {
-      println!("Creating directory dest: {}", dest.display());
+
+  if !template_info.is_empty {
+    for file in template_info.selected_files.iter().filter(|x| x.starts_with(&project_data_root)) {
+      let trimmed_file = file.strip_prefix(&project_data_root)
+        .map_err(|_| errors::str_error("Failed to strip prefix"))?;
+      let from = package_cache_dir.join(file);
+      let dest = package_cache_dir_out.join(trimmed_file);
+      println!("Copying {} to {}", from.display(), dest.display());
+
       std::fs::create_dir_all(&dest)?;
-    } else {
-      println!("Creating directory parent: {} for {}", dest.parent().unwrap().display(), dest.display());
-      std::fs::create_dir_all(dest.parent().unwrap())?;
-      if let Err(err) = std::fs::copy(&from, &dest) {
-        println!("Failed to copy from {} to {}: {}", from.display(), dest.display(), err);
+      
+      if dest.extension().is_none() {
+        println!("Creating directory dest: {}", dest.display());
+        // std::fs::create_dir_all(&dest)?;
+      } else {
+        println!("Creating directory parent: {} for {}", dest.parent().unwrap().display(), dest.display());
+        // std::fs::create_dir_all(dest.parent().unwrap())?;
+        if let Err(err) = std::fs::copy(&from, &dest) {
+          println!("Failed to copy from {} to {}: {}", from.display(), dest.display(), err);
+        }
       }
-    }
+    } 
   }
 
   // remove cache
@@ -201,6 +237,13 @@ pub fn generate_template(app: &tauri::AppHandle, app_state: &tauri::State<AppSta
 }
 
 fn unpack_package_into_cache(output: &PathBuf, template_info: &TemplateInfoForGeneration) -> Result<(), errors::AnyError> {
+  if template_info.template.is_none() {
+    let package_path = output.join("package");
+    std::fs::create_dir_all(&package_path)?;
+    
+    return Ok(());
+  }
+  
   let template = template_info.template
     .as_ref()
     .ok_or(errors::str_error("Template not found"))?
@@ -217,17 +260,15 @@ fn unpack_package_into_cache(output: &PathBuf, template_info: &TemplateInfoForGe
   Ok(())
 }
 
-fn modify_package_json(package_cache_dir: &PathBuf, packages: &Vec<MinimalPackage>, output_path: &PathBuf) -> Result<(), errors::AnyError> {
+fn modify_package_json(json_root: &PathBuf, packages: &Vec<MinimalPackage>, output_path: &PathBuf) -> Result<(), errors::AnyError> {
   // modify package.json for dependencies
-  let packages_dir = package_cache_dir
-    .join("package")
-    .join("ProjectData~")
-    .join("Packages");
-  let manifest_json = packages_dir
+  std::fs::create_dir_all(&json_root)?;
+  
+  let manifest_json = json_root
     .join("manifest")
     .with_extension("json");
 
-  let packages_lock_json = packages_dir
+  let packages_lock_json = json_root
     .join("packages-lock")
     .with_extension("json");
 
@@ -249,7 +290,13 @@ fn modify_package_json(package_cache_dir: &PathBuf, packages: &Vec<MinimalPackag
   println!("Local packages: {:?}", local_packages);
   println!("Rest packages: {:?}", rest_packages);
 
-  let manifest_json_contents = std::fs::read_to_string(&manifest_json)?;
+  let manifest_json_contents = {
+    if !manifest_json.exists() {
+      "{}".to_string()
+    } else {
+      std::fs::read_to_string(&manifest_json)?
+    }
+  };
   let mut manifest_json_contents: HashMap<String, serde_json::Value> 
     = serde_json::from_str(&manifest_json_contents)?;
 
@@ -309,8 +356,8 @@ fn modify_package_json(package_cache_dir: &PathBuf, packages: &Vec<MinimalPackag
 // commands
 
 #[tauri::command]
-pub async fn cmd_generate_project(app: tauri::AppHandle, project_info: ProjectInfoForGeneration, template_info: TemplateInfoForGeneration) -> Result<PathBuf, errors::AnyError> {
-  let output = generate_project(&app, &project_info, &template_info)?;
+pub async fn cmd_generate_project(app: tauri::AppHandle, app_state: tauri::State<'_, AppState>, project_info: ProjectInfoForGeneration, template_info: TemplateInfoForGeneration) -> Result<PathBuf, errors::AnyError> {
+  let output = generate_project(&app, &app_state, &project_info, &template_info)?;
   Ok(output)
 }
 

src-tauri/src/project.rs

@@ -175,7 +175,7 @@ pub fn cmd_open_project_in_editor(app_state: tauri::State<AppState>, project_pat
         .to_string();
 
     let args = vec!["-projectPath".to_string(), project_path_str];
-    crate::editor::open(editor_version, args, &app_state)?;
+    crate::editor::open(editor_version, args, &app_state, false)?;
 
     Ok(())
 }

src/context/new-project-context.tsx

@@ -163,7 +163,9 @@ export namespace NewProjectContext {
     | { type: "add_git_package"; package: { id: string; url: string } }
     | { type: "add_local_package"; package: { path: string } }
     | { type: "remove_git_package"; package: TauriTypes.MinimalPackage }
-    | { type: "remove_local_package"; package: TauriTypes.MinimalPackage };
+    | { type: "remove_local_package"; package: TauriTypes.MinimalPackage }
+    | { type: "set_git_packages"; packages: TauriTypes.MinimalPackage[] }
+    | { type: "set_local_packages"; packages: TauriTypes.MinimalPackage[] };
 
   const reducer = (state: State, action: Action): State => {
     switch (action.type) {
@@ -298,6 +300,22 @@ export namespace NewProjectContext {
             description: action.description,
           },
         };
+      case "set_git_packages":
+        return {
+          ...state,
+          packageInfo: {
+            ...state.packageInfo,
+            gitPackages: action.packages,
+          },
+        };
+      case "set_local_packages":
+        return {
+          ...state,
+          packageInfo: {
+            ...state.packageInfo,
+            localPackages: action.packages,
+          },
+        };
       case "add_git_package":
         return {
           ...state,

src/utils/tauri-types.ts

@@ -155,6 +155,7 @@ export namespace TauriTypes {
     editorVersion: UnityEditorInstall;
     packages: MinimalPackage[];
     selectedFiles: string[]; // PathBuf is usually represented as a string in TS
+    isEmpty: boolean;
   }
 
   export interface ProjectInfoForGeneration {

src/views/new-project/basic-info-view.tsx

@@ -193,8 +193,8 @@ export function NewProjectOverview(props: {
         <span className="ml-auto">{packageInfo.selectedPackages.length}</span>
       </div>
       {packageInfo.selectedPackages.map((p) => (
-        <p key={p} className="text-stone-400 w-full pl-4">
-          - {p}
+        <p key={p.name + p.version} className="text-stone-400 w-full pl-4">
+          - {p.name} @ {p.version}
         </p>
       ))}
 

src/views/new-project/new-project-body.tsx

@@ -78,6 +78,7 @@ export default function NewProjectBody() {
           "package/package.json.meta",
           ...trimmedPaths,
         ],
+        isEmpty: false,
       };
       const template: TauriTypes.NewTemplateInfo = {
         template: templateInfo,
@@ -141,6 +142,7 @@ export default function NewProjectBody() {
           )
         ),
         selectedFiles: trimmedPaths,
+        isEmpty: template.selectedTemplate === undefined,
       };
       const projectInfo: TauriTypes.ProjectInfoForGeneration = {
         name: basicInfo.name,

src/views/new-project/package-view.tsx

@@ -40,28 +40,35 @@ export default function PackageView() {
           }))
         )
         .then(async (x) => {
-          const p = await TauriRouter.get_user_cache();
-          const gitPackages = p.gitPackages.map((x) => ({
-            package_: x,
-            category: "Git",
-          }));
-
-          const localPackages = p.localPackages.map((x) => ({
-            package_: x,
-            category: "Local",
-          }));
-          return [...x, ...gitPackages, ...localPackages];
+          return [...x];
         });
 
       minimalPackages.set({
         status: "success",
-        // value: newMinimalPackages.filter((x) => x.isFile),
-        // value: newMinimalPackages.map((x) => ({
-        //   package_: x,
-        //   category: "Internal",
-        // })),
         value: newMinimalPackages,
       });
+
+      const p = await TauriRouter.get_user_cache();
+
+      const gitPackages = p.gitPackages.map((x) => ({
+        package_: x,
+        category: "Git",
+      }));
+
+      const localPackages = p.localPackages.map((x) => ({
+        package_: x,
+        category: "Local",
+      }));
+
+      newProjectContext.dispatch({
+        type: "set_git_packages",
+        packages: gitPackages.map((x) => x.package_),
+      });
+
+      newProjectContext.dispatch({
+        type: "set_local_packages",
+        packages: localPackages.map((x) => x.package_),
+      });
     };
     load();
   }, []);
@@ -96,12 +103,6 @@ export default function PackageView() {
     } else {
       selectPackage(name, version);
     }
-
-    // if (packages.includes(x)) {
-    //   removePackage(x);
-    // } else {
-    //   selectPackage(x);
-    // }
   }
 
   const queriedPackages = useMemo(() => {
@@ -335,12 +336,12 @@ function GitAdd(props: {
         });
 
         props.selectPackage(name, version);
+
+        gitPackageJson.set("");
       } catch (e) {
         console.error(e);
         return;
       }
-
-      gitPackageJson.set("");
     }
   }
 
@@ -587,7 +588,7 @@ function Package({
           <p className="flex basis-full text-stone-50 select-none">
             {package_.package_.name}{" "}
             <span
-              className={`ml-auto ${
+              className={`ml-auto text-right ${
                 selected ? "text-stone-50" : "text-stone-400"
               }`}
             >