Split internal packages into default ones too

Author: nomnomab

src-tauri/src/editor.rs

@@ -50,6 +50,25 @@ impl Default for UnityEditorModule {
   }
 }
 
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditorPackageManagerManifestPackage {
+  pub is_discoverable: Option<bool>,
+  pub must_be_bundled: Option<bool>,
+  pub version: Option<String>,
+  pub minimum_version: Option<String>,
+  pub deprecated: Option<String>,
+  pub remove_on_project_upgrade: Option<bool>,
+  pub is_default: Option<bool>,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditorPackageManagerManifest {
+  schema_version: u32,
+  pub packages: HashMap<String, EditorPackageManagerManifestPackage>,
+}
+
 pub fn get_root_folder(editor_path: impl Into<PathBuf>) -> Option<std::path::PathBuf> {
   let path: PathBuf = editor_path.into();
   // path is to exe, so go up two folders
@@ -301,6 +320,26 @@ pub fn estimate_size(
   Ok(disk_size)
 }
 
+pub fn read_package_manager_manifest(editor_version: String, app_state: &tauri::State<AppState>) -> Result<EditorPackageManagerManifest, errors::AnyError> {
+  let editor = app_state.editors.lock()
+    .map_err(|_| errors::str_error("Failed to get editors. Is it locked?"))?
+    .iter()
+    .find(|x| x.version == editor_version)
+    .ok_or(errors::str_error("Invalid editor version"))?
+    .clone();
+  let root_dir = crate::editor::get_package_manager_folder(&editor)?;
+  let manifest_path = root_dir
+    .join("Editor")
+    .join("manifest")
+    .with_extension("json");
+
+  let json = std::fs::read_to_string(&manifest_path)
+    .map_err(|_| errors::io_not_found("Invalid package manager manifest"))?;
+  let manifest: EditorPackageManagerManifest = serde_json::from_str(&json)
+    .map_err(|_| errors::str_error("Invalid package manager manifest"))?;
+  Ok(manifest)
+}
+
 // commands
 
 #[tauri::command]

src-tauri/src/package.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::{app::AppState, errors};
+use crate::{app::AppState, errors, template};
 
 pub struct Package {
   pub name: String,
@@ -13,30 +13,31 @@ pub struct Package {
   pub authors: Vec<String>,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct PackageManagerEditorManifest {
-  pub schema_version: u64,
-  pub packages: HashMap<String, PackageManagerEditorManifestPackage>,
-  pub metadata_package_name: String
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct PackageManagerEditorManifestPackage {
-  pub is_discoverable: Option<bool>,
-  pub must_be_bundled: Option<bool>,
-  pub version: Option<String>,
-  pub minimum_version: Option<String>,
-  pub deprecated: Option<String>,
-  pub remove_on_project_upgrade: Option<bool>,
-  pub is_file: Option<bool>
-}
+// #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+// #[serde(rename_all = "camelCase")]
+// pub struct PackageManagerEditorManifest {
+//   pub schema_version: u64,
+//   pub packages: HashMap<String, PackageManagerEditorManifestPackage>,
+//   pub metadata_package_name: String
+// }
+
+// #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+// #[serde(rename_all = "camelCase")]
+// pub struct PackageManagerEditorManifestPackage {
+//   pub is_discoverable: Option<bool>,
+//   pub must_be_bundled: Option<bool>,
+//   pub version: Option<String>,
+//   pub minimum_version: Option<String>,
+//   pub deprecated: Option<String>,
+//   pub remove_on_project_upgrade: Option<bool>,
+//   pub is_file: Option<bool>
+// }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub enum PackageType {
   Internal,
+  Default,
   Git,
   Local
 }
@@ -46,71 +47,71 @@ pub enum PackageType {
 pub struct MinimalPackage { 
   pub name: String,
   pub version: String,
-  pub is_file: bool,
+  // pub is_file: bool,
   pub is_discoverable: bool,
   pub _type: PackageType
 }
 
-pub fn get_editor_package_manager_manifest(editor_version: String, app_state: &tauri::State<AppState>) -> Result<PackageManagerEditorManifest, errors::AnyError> {
-  let editor = app_state.editors.lock()
-    .map_err(|_| errors::str_error("Failed to get editors. Is it locked?"))?
-    .iter()
-    .find(|x| x.version == editor_version)
-    .ok_or(errors::str_error("Invalid editor version"))?
-    .clone();
-
-  let root_path = crate::editor::get_root_folder(editor.exe_path.clone());
-  let manifest_folder_path = crate::editor::get_package_manager_folder(&editor)?;
-  let manifest_folder_path = manifest_folder_path
-    .join("Editor");
-
-  let manifest_path = manifest_folder_path
-    .join("manifest")
-    .with_extension("json");
-
-  if !manifest_path.exists() {
-    return Err(errors::io_not_found("Invalid manifest path"));
-  }
-
-  let manifest_contents = std::fs::read_to_string(&manifest_path)
-    .map_err(|_| errors::io_not_found("Invalid manifest file"))?;
-
-  let mut manifest: PackageManagerEditorManifest = serde_json::from_str(&manifest_contents)
-    .map_err(|_| errors::io_not_found("Invalid manifest file"))?;
-
-  let files = std::fs::read_dir(&manifest_folder_path)
-    .map_err(|_| errors::io_not_found("Invalid manifest file"))?
-    .filter_map(|x| x.ok())
-    .filter_map(|x| x.file_name().to_str().map(|x| x.to_string()))
-    .collect::<Vec<_>>();
-
-  for (key, package) in manifest.packages.iter_mut() {
-    let version = package.version.clone();
-    if let Some(version) = version {
-      package.is_file = Some(files.contains(&format!("{}-{}.tgz", &key, version)));
-    } else {
-      package.is_file = None;
-    }
-  }
-
-  Ok(manifest)
-}
+// pub fn get_editor_package_manager_manifest(editor_version: String, app_state: &tauri::State<AppState>) -> Result<PackageManagerEditorManifest, errors::AnyError> {
+//   let editor = app_state.editors.lock()
+//     .map_err(|_| errors::str_error("Failed to get editors. Is it locked?"))?
+//     .iter()
+//     .find(|x| x.version == editor_version)
+//     .ok_or(errors::str_error("Invalid editor version"))?
+//     .clone();
+
+//   let root_path = crate::editor::get_root_folder(editor.exe_path.clone());
+//   let manifest_folder_path = crate::editor::get_package_manager_folder(&editor)?;
+//   let manifest_folder_path = manifest_folder_path
+//     .join("Editor");
+
+//   let manifest_path = manifest_folder_path
+//     .join("manifest")
+//     .with_extension("json");
+
+//   if !manifest_path.exists() {
+//     return Err(errors::io_not_found("Invalid manifest path"));
+//   }
+
+//   let manifest_contents = std::fs::read_to_string(&manifest_path)
+//     .map_err(|_| errors::io_not_found("Invalid manifest file"))?;
+
+//   let mut manifest: PackageManagerEditorManifest = serde_json::from_str(&manifest_contents)
+//     .map_err(|_| errors::io_not_found("Invalid manifest file"))?;
+
+//   let files = std::fs::read_dir(&manifest_folder_path)
+//     .map_err(|_| errors::io_not_found("Invalid manifest file"))?
+//     .filter_map(|x| x.ok())
+//     .filter_map(|x| x.file_name().to_str().map(|x| x.to_string()))
+//     .collect::<Vec<_>>();
+
+//   for (key, package) in manifest.packages.iter_mut() {
+//     let version = package.version.clone();
+//     if let Some(version) = version {
+//       package.is_file = Some(files.contains(&format!("{}-{}.tgz", &key, version)));
+//     } else {
+//       package.is_file = None;
+//     }
+//   }
+
+//   Ok(manifest)
+// }
 
 // commands
 
 // need to override versions with current template versions
 #[tauri::command]
 pub fn cmd_get_default_editor_packages(editor_version: String, app_state: tauri::State<AppState>) -> Result<Vec<MinimalPackage>, errors::AnyError> {
-  let manifest = get_editor_package_manager_manifest(editor_version, &app_state)?;
+  let manifest = crate::editor::read_package_manager_manifest(editor_version, &app_state)?;
   let mut manifest_packages = manifest.packages
     .iter()
     // .filter(|x| x.1.is_discoverable == Some(true))
     .map(|x| MinimalPackage {
       name: x.0.clone(),
       version: x.1.version.clone().unwrap_or_default(),
-      is_file: x.1.is_file.unwrap_or(false),
+      // is_file: x.1.is_file.unwrap_or(false),
       is_discoverable: x.1.is_discoverable.unwrap_or(false),
-      _type: PackageType::Internal
+      _type: x.1.is_default.unwrap_or(false).then(|| PackageType::Default).unwrap_or(PackageType::Internal)
     })
     .collect::<Vec<_>>();
 

src-tauri/src/template.rs

@@ -87,25 +87,6 @@ pub enum UnityPipeline {
   Custom,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct EditorPackageManagerManifestPackage {
-  is_discoverable: Option<bool>,
-  must_be_bundled: Option<bool>,
-  version: Option<String>,
-  minimum_version: Option<String>,
-  deprecated: Option<String>,
-  remove_on_project_upgrade: Option<bool>,
-  is_default: Option<bool>,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct EditorPackageManagerManifest {
-  schema_version: u32,
-  packages: HashMap<String, EditorPackageManagerManifestPackage>,
-}
-
 // pub struct SurfaceTemplateRecord {
 //   pub template: SurfaceTemplate,
 //   pub category: String,
@@ -221,26 +202,6 @@ pub fn get_user_templates(editor_version: String, app_state: &tauri::State<AppSt
   Ok(files.collect())
 }
 
-pub fn read_package_manager_manifest(editor_version: String, app_state: &tauri::State<AppState>) -> Result<EditorPackageManagerManifest, errors::AnyError> {
-  let editor = app_state.editors.lock()
-    .map_err(|_| errors::str_error("Failed to get editors. Is it locked?"))?
-    .iter()
-    .find(|x| x.version == editor_version)
-    .ok_or(errors::str_error("Invalid editor version"))?
-    .clone();
-  let root_dir = crate::editor::get_package_manager_folder(&editor)?;
-  let manifest_path = root_dir
-    .join("Editor")
-    .join("manifest")
-    .with_extension("json");
-
-  let json = std::fs::read_to_string(&manifest_path)
-    .map_err(|_| errors::io_not_found("Invalid package manager manifest"))?;
-  let manifest: EditorPackageManagerManifest = serde_json::from_str(&json)
-    .map_err(|_| errors::str_error("Invalid package manager manifest"))?;
-  Ok(manifest)
-}
-
 pub fn extract_template_information(app: &tauri::AppHandle, app_state: &tauri::State<AppState>, surface_template: &SurfaceTemplate) -> Result<TgzPackageJsonRecord, errors::AnyError> {
   let file_name = surface_template.path.file_name()
     .ok_or(errors::str_error("Invalid template file name"))?;
@@ -343,7 +304,7 @@ pub fn extract_template_information(app: &tauri::AppHandle, app_state: &tauri::S
           }
         }
       } else {
-        if let Ok(manifest) = read_package_manager_manifest(surface_template.editor_version.clone(), &app_state) {
+        if let Ok(manifest) = crate::editor::read_package_manager_manifest(surface_template.editor_version.clone(), &app_state) {
           manifest
             .packages
             .iter()

src/utils/tauri-types.ts

@@ -122,6 +122,7 @@ export namespace TauriTypes {
 
   export enum PackageType {
     Internal = "internal",
+    Default = "default",
     Git = "git",
     Local = "local",
   }