com.elestrago.unity.package-tools 2.5.2 → 2.5.3

package/Editor/CIUtils.cs

@@ -1,4 +1,5 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -9,7 +10,8 @@ using UnityEngine;
 namespace PackageTool
 {
 	/// <summary>
-	/// Continuous-integration API for package tools.
+	/// Continuous-integration API for package tools. Every entry point here is meant to be invoked through
+	/// Unity's -executeMethod and reads its arguments as key=value command-line pairs.
 	/// </summary>
 	public static class CIUtils
 	{
@@ -18,6 +20,8 @@ namespace PackageTool
 		private const string VERSION_ARG_KEY = "version";
 		private const string PREVIEW_ARG_KEY = "preview";
 		private const string GENERATE_VERSION_CONSTANTS_ARG_KEY = "generateversionconstants";
+		private const string RESULT_PATH_ARG_KEY = "resultpath";
+		private const string EXIT_ON_FINISH_ARG_KEY = "exitonfinish";
 
 		// Logs
 		private const string LOG_PREFIX = "[Package Tools] ";
@@ -49,6 +53,10 @@ namespace PackageTool
 		private const string CI_SKIPPING_PACKAGE_SOURCE_FORMAT = LOG_PREFIX +
 		                                                         "Skipping Package Source for Config [{0}] with ID: [{1}] as no output path is present in config.";
 
+		private const string CI_LISTING_CONFIGS = LOG_PREFIX + "Listing [{0}] configs in project.";
+		private const string CI_EXPORT_FAILED_FORMAT = LOG_PREFIX + "Export failed for [{0}]:\n\n{1}";
+		private const string CI_UNEXPECTED_ERROR_FORMAT = "An unexpected error occured during package generation:\n\n{0}";
+
 		private static readonly StringBuilder StringBuilder;
 
 		private static bool IsRunningOnCI => !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("CI"));
@@ -66,123 +74,232 @@ namespace PackageTool
 		{
 			Debug.Log(CI_STARTING);
 
-			PrepareDll();
+			PrepareDllInternal();
+
+			var commandLineArgs = GetLoggedCommandLineArguments();
+			var results = new List<CIResultModel>();
+			var hasError = false;
 
 			try
 			{
 				EditorApplication.LockReloadAssemblies();
 				AssetDatabase.StartAssetEditing();
 
-				// Get command line args and log them
-				var commandLineArgs = CommandLineTools.GetKVPCommandLineArguments();
-
-				StringBuilder.Clear();
-				const string cliArgFormat = "{0} => {1}";
-				foreach (var commandLineArg in commandLineArgs)
-				{
-					StringBuilder.AppendFormat(cliArgFormat, commandLineArg.Key, commandLineArg.Value);
-					StringBuilder.AppendLine();
-				}
-
-				Debug.LogFormat(CI_COMMAND_LINE_ARGS_PARSED_FORMAT, StringBuilder);
-
 				// Attempt to parse CLI-passed version, if present.
-				string version = null;
-				if (commandLineArgs.TryGetValue(VERSION_ARG_KEY, out var versionRawValue))
-					version = (string)versionRawValue;
+				var version = GetStringArgument(commandLineArgs, VERSION_ARG_KEY);
 
-				// Attempt to parse CLI-passed version, if present.
+				// Attempt to parse CLI-passed preview flag, if present.
 				bool? isPreview = null;
 				if (commandLineArgs.TryGetValue(PREVIEW_ARG_KEY, out var previewRawValue))
 					isPreview = bool.Parse((string)previewRawValue);
 
 				// See if we should generate version constants
-				var generateVersionConstants = false;
-				if (commandLineArgs.TryGetValue(
-					    GENERATE_VERSION_CONSTANTS_ARG_KEY,
-					    out var generateVersionConstantsRawValue))
-					generateVersionConstants = bool.Parse(generateVersionConstantsRawValue.ToString());
+				var generateVersionConstants = GetBoolArgument(commandLineArgs, GENERATE_VERSION_CONSTANTS_ARG_KEY);
 
 				// Get all package manifests in project
-				var allPackageManifestConfigs = PackageManifestTools.GetAllConfigs();
+				var allPackageManifestConfigs = PackageToolApi.GetConfigs();
 
 				Debug.LogFormat(CI_FOUND_CONFIGS, allPackageManifestConfigs.Length);
 
 				// Check to see if any IDs have been passed for specific configs
-				string[] configIds;
-				if (commandLineArgs.TryGetValue(ID_ARG_KEY, out var arg))
-				{
-					Debug.Log(CI_USING_ONLY_CONFIGS_FROM_ARG);
-
-					const char commaChar = ',';
-					var idArgValue = arg.ToString();
-					configIds = idArgValue.Split(commaChar);
-				}
-				// Otherwise generate all package manifest configs in project.
-				else
-				{
-					Debug.Log(CI_USING_ALL_CONFIGS);
+				var selectors = GetSelectors(commandLineArgs, allPackageManifestConfigs);
 
-					configIds = allPackageManifestConfigs.Select(x => x.Id).ToArray();
-				}
-
-				// For each matching config ID, find the matching package manifest config and generate any relevant packages.
+				// For each matching selector, find the matching package manifest config and generate any relevant packages.
 				Debug.Log(CI_GENERATION_STARTING);
-				foreach (var configId in configIds)
+				foreach (var selector in selectors)
 				{
-					var matchingConfig = allPackageManifestConfigs.FirstOrDefault(x =>
-						string.Compare(x.Id, configId, StringComparison.OrdinalIgnoreCase) == 0);
+					var matchingConfig = PackageToolApi.FindConfig(selector, allPackageManifestConfigs);
 
-					// If a config cannot be found matching config id, skip it and continue.
+					// If a config cannot be found matching the selector, skip it and continue.
 					if (matchingConfig == null)
 					{
-						Debug.LogWarningFormat(CI_PACKAGE_NOT_FOUND_FORMAT, configId);
+						Debug.LogWarningFormat(CI_PACKAGE_NOT_FOUND_FORMAT, selector);
+						results.Add(CIResultModel.CreateFailure(
+							selector,
+							string.Format(EditorConstants.CONFIG_NOT_FOUND_ERROR_FORMAT, selector)));
 
 						continue;
 					}
 
 					var configName = matchingConfig.name;
+					var configId = matchingConfig.Id;
+					var result = CIResultModel.CreateForConfig(selector, matchingConfig);
+					results.Add(result);
 
 					Debug.LogFormat(CI_PACKAGE_FOUND_FORMAT, configName, configId);
 
-					// Set the CLI passed version if present, otherwise default to checked in version number.
-					if (!string.IsNullOrEmpty(version))
+					try
 					{
-						matchingConfig.packageVersion = version;
-						EditorUtility.SetDirty(matchingConfig);
+						// If set to generate version constants, do so.
+						if (generateVersionConstants)
+							result.VersionConstantsPath = PackageToolApi.GenerateVersionConstants(matchingConfig);
+
+						// Otherwise generate the corresponding legacy unity package and package source if their
+						// output paths have been defined
+						if (!string.IsNullOrEmpty(matchingConfig.legacyPackageDestinationPath))
+						{
+							Debug.LogFormat(CI_GENERATING_LEGACY_PACKAGE_FORMAT, configName, configId);
+
+							result.LegacyPackagePath = PackageToolApi.ExportLegacyPackage(matchingConfig, version);
+						}
+						else
+						{
+							Debug.LogFormat(CI_SKIPPING_LEGACY_PACKAGE_FORMAT, configName, configId);
+						}
+
+						if (!string.IsNullOrEmpty(matchingConfig.packageDestinationPath))
+						{
+							Debug.LogFormat(CI_GENERATING_PACKAGE_SOURCE_FORMAT, configName, configId);
+
+							result.PackageSourcePath = PackageToolApi.ExportPackageSource(matchingConfig, version);
+						}
+						else
+						{
+							Debug.LogFormat(CI_SKIPPING_PACKAGE_SOURCE_FORMAT, configName, configId);
+						}
+
+						result.PackageVersion = matchingConfig.packageVersion;
 					}
+					catch (Exception e)
+					{
+						result.Success = false;
+						result.Error = e.Message;
+						hasError = true;
+
+						Debug.LogErrorFormat(CI_EXPORT_FAILED_FORMAT, configName, e);
+					}
+				}
+			}
+			catch (Exception e)
+			{
+				results.Add(CIResultModel.CreateFailure(null, e.Message));
+				hasError = true;
+
+				Debug.LogErrorFormat(CI_UNEXPECTED_ERROR_FORMAT, e);
+			}
+			finally
+			{
+				AssetDatabase.StopAssetEditing();
+				EditorApplication.UnlockReloadAssemblies();
+			}
+
+			Debug.Log(CI_COMPLETE);
+
+			// Generate has always logged and continued on a missing config, so it only fails on a real error.
+			Finish(commandLineArgs, results, !hasError);
+		}
+
+		/// <summary>
+		/// Writes every <see cref="PackageManifestConfig"/> in the project to the file passed in the
+		/// 'resultpath' argument so that callers can discover which selectors are valid.
+		/// </summary>
+		public static void ListConfigs()
+		{
+			var commandLineArgs = GetLoggedCommandLineArguments();
+			var configs = PackageToolApi.GetConfigs();
+
+			Debug.LogFormat(CI_LISTING_CONFIGS, configs.Length);
 
-					// If set to generate version constants, do so.
-					if (generateVersionConstants) CodeGenTools.GenerateVersionConstants(matchingConfig);
+			var models = configs.Select(CIConfigModel.CreateFromConfig).ToList();
 
-					// Otherwise generate the corresponding legacy unity package and package source if their output paths
-					// have been defined
-					if (!string.IsNullOrEmpty(matchingConfig.legacyPackageDestinationPath))
+			CIResultTools.WriteResultFile(GetStringArgument(commandLineArgs, RESULT_PATH_ARG_KEY), models);
+
+			ExitIfRequested(commandLineArgs, true);
+		}
+
+		/// <summary>
+		/// Exports the package source of every selected <see cref="PackageManifestConfig"/>.
+		/// </summary>
+		public static void ExportPackageSource() => RunExport(exportSource: true, exportLegacy: false);
+
+		/// <summary>
+		/// Exports every selected <see cref="PackageManifestConfig"/> as a legacy unity package.
+		/// </summary>
+		public static void ExportLegacyPackage() => RunExport(exportSource: false, exportLegacy: true);
+
+		private static void RunExport(bool exportSource, bool exportLegacy)
+		{
+			var commandLineArgs = GetLoggedCommandLineArguments();
+			var results = new List<CIResultModel>();
+
+			try
+			{
+				EditorApplication.LockReloadAssemblies();
+				AssetDatabase.StartAssetEditing();
+
+				var version = GetStringArgument(commandLineArgs, VERSION_ARG_KEY);
+				var generateVersionConstants = GetBoolArgument(commandLineArgs, GENERATE_VERSION_CONSTANTS_ARG_KEY);
+				var allConfigs = PackageToolApi.GetConfigs();
+
+				Debug.LogFormat(CI_FOUND_CONFIGS, allConfigs.Length);
+
+				foreach (var selector in GetSelectors(commandLineArgs, allConfigs))
+				{
+					PackageManifestConfig config;
+					try
+					{
+						config = PackageToolApi.FindConfig(selector, allConfigs);
+					}
+					catch (Exception e)
 					{
-						Debug.LogFormat(CI_GENERATING_LEGACY_PACKAGE_FORMAT, configName, configId);
+						results.Add(CIResultModel.CreateFailure(selector, e.Message));
 
-						UnityFileTools.CompileLegacyPackage(matchingConfig);
+						Debug.LogErrorFormat(CI_EXPORT_FAILED_FORMAT, selector, e);
+
+						continue;
 					}
-					else
+
+					// Unlike Generate, asking for a package that is not there is a failure and not a skip.
+					if (config == null)
 					{
-						Debug.LogFormat(CI_SKIPPING_LEGACY_PACKAGE_FORMAT, configName, configId);
+						var error = string.Format(EditorConstants.CONFIG_NOT_FOUND_ERROR_FORMAT, selector);
+						results.Add(CIResultModel.CreateFailure(selector, error));
+
+						Debug.LogError(error);
+
+						continue;
 					}
 
-					if (!string.IsNullOrEmpty(matchingConfig.packageDestinationPath))
+					var result = CIResultModel.CreateForConfig(selector, config);
+					results.Add(result);
+
+					Debug.LogFormat(CI_PACKAGE_FOUND_FORMAT, config.name, config.Id);
+
+					try
 					{
-						Debug.LogFormat(CI_GENERATING_PACKAGE_SOURCE_FORMAT, configName, configId);
+						if (generateVersionConstants)
+							result.VersionConstantsPath = PackageToolApi.GenerateVersionConstants(config);
+
+						if (exportLegacy)
+						{
+							Debug.LogFormat(CI_GENERATING_LEGACY_PACKAGE_FORMAT, config.name, config.Id);
+
+							result.LegacyPackagePath = PackageToolApi.ExportLegacyPackage(config, version);
+						}
+
+						if (exportSource)
+						{
+							Debug.LogFormat(CI_GENERATING_PACKAGE_SOURCE_FORMAT, config.name, config.Id);
 
-						FileTools.CreateOrUpdatePackageSource(matchingConfig);
+							result.PackageSourcePath = PackageToolApi.ExportPackageSource(config, version);
+						}
+
+						result.PackageVersion = config.packageVersion;
 					}
-					else
+					catch (Exception e)
 					{
-						Debug.LogFormat(CI_SKIPPING_PACKAGE_SOURCE_FORMAT, configName, configId);
+						result.Success = false;
+						result.Error = e.Message;
+
+						Debug.LogErrorFormat(CI_EXPORT_FAILED_FORMAT, config.name, e);
 					}
 				}
 			}
 			catch (Exception e)
 			{
-				Debug.LogErrorFormat("An unexpected error occured during package generation:\n\n{0}", e);
+				results.Add(CIResultModel.CreateFailure(null, e.Message));
+
+				Debug.LogErrorFormat(CI_UNEXPECTED_ERROR_FORMAT, e);
 			}
 			finally
 			{
@@ -190,17 +307,30 @@ namespace PackageTool
 				EditorApplication.UnlockReloadAssemblies();
 			}
 
-			Debug.Log(CI_COMPLETE);
+			Finish(commandLineArgs, results, results.Count > 0 && results.All(x => x.Success));
 		}
 
+		/// <summary>
+		/// Sets the platform compatibility of every plugin in the source path of the project's
+		/// <see cref="PackageManifestConfig"/> so that editor assemblies are not shipped as runtime ones.
+		/// This is a command-line entry point in its own right, so it exits the editor when running on CI.
+		/// </summary>
 		[MenuItem("Tools/PackageTools/PrepareDll")]
 		public static void PrepareDll()
+		{
+			var success = PrepareDllInternal();
+
+			if (IsRunningOnCI)
+				EditorApplication.Exit(success ? 0 : 1);
+		}
+
+		private static bool PrepareDllInternal()
 		{
 			try
 			{
 				Debug.Log($"[{nameof(CIUtils)}] PrepareDll");
 
-				var packageManifestConfig = PackageManifestTools.GetAllConfigs().Single();
+				var packageManifestConfig = PackageToolApi.GetConfigs().Single();
 				var sourcePath = packageManifestConfig.sourcePath;
 
 				Debug.Log($"[{nameof(CIUtils)}] Find assets in path: {sourcePath}");
@@ -231,17 +361,86 @@ namespace PackageTool
 				}
 
 				Debug.Log($"[{nameof(CIUtils)}] Complete dll import");
+
+				return true;
 			}
 			catch (Exception e)
 			{
 				Debug.LogException(e);
 
-				if (IsRunningOnCI)
-					EditorApplication.Exit(1);
+				return false;
 			}
+		}
 
-			if (IsRunningOnCI)
-				EditorApplication.Exit(0);
+		private static Dictionary<string, object> GetLoggedCommandLineArguments()
+		{
+			var commandLineArgs = CommandLineTools.GetKVPCommandLineArguments();
+
+			StringBuilder.Clear();
+			const string cliArgFormat = "{0} => {1}";
+			foreach (var commandLineArg in commandLineArgs)
+			{
+				StringBuilder.AppendFormat(cliArgFormat, commandLineArg.Key, commandLineArg.Value);
+				StringBuilder.AppendLine();
+			}
+
+			Debug.LogFormat(CI_COMMAND_LINE_ARGS_PARSED_FORMAT, StringBuilder);
+
+			return commandLineArgs;
+		}
+
+		/// <summary>
+		/// Returns the selectors passed in the 'id' argument, or a selector for every config in the project
+		/// when the argument is absent. A selector is a config id, a package name or a config asset name.
+		/// </summary>
+		private static string[] GetSelectors(
+			Dictionary<string, object> commandLineArgs,
+			PackageManifestConfig[] allConfigs)
+		{
+			if (commandLineArgs.TryGetValue(ID_ARG_KEY, out var arg) && arg != null)
+			{
+				Debug.Log(CI_USING_ONLY_CONFIGS_FROM_ARG);
+
+				const char commaChar = ',';
+
+				return arg.ToString()
+					.Split(commaChar)
+					.Select(x => x.Trim())
+					.Where(x => !string.IsNullOrEmpty(x))
+					.ToArray();
+			}
+
+			Debug.Log(CI_USING_ALL_CONFIGS);
+
+			return allConfigs.Select(x => x.Id).ToArray();
+		}
+
+		private static string GetStringArgument(Dictionary<string, object> commandLineArgs, string key)
+		{
+			return commandLineArgs.TryGetValue(key, out var rawValue) ? (string)rawValue : null;
+		}
+
+		private static bool GetBoolArgument(Dictionary<string, object> commandLineArgs, string key)
+		{
+			return commandLineArgs.TryGetValue(key, out var rawValue) && bool.Parse(rawValue.ToString());
+		}
+
+		private static void Finish(
+			Dictionary<string, object> commandLineArgs,
+			IReadOnlyList<CIResultModel> results,
+			bool success)
+		{
+			// The result file is always written before a potential exit so callers never race the editor.
+			CIResultTools.WriteResultFile(GetStringArgument(commandLineArgs, RESULT_PATH_ARG_KEY), results);
+
+			ExitIfRequested(commandLineArgs, success);
+		}
+
+		private static void ExitIfRequested(Dictionary<string, object> commandLineArgs, bool success)
+		{
+			var exitOnFinish = IsRunningOnCI || GetBoolArgument(commandLineArgs, EXIT_ON_FINISH_ARG_KEY);
+			if (exitOnFinish)
+				EditorApplication.Exit(success ? 0 : 1);
 		}
 	}
-}
+}

package/Editor/EditorConstants.cs

@@ -41,7 +41,6 @@ namespace PackageTool
 		public const string ASSET_EXTENSION = ".asset";
 		public const string META_EXTENSION = ".meta";
 		public const string META_FORMAT = "{0}" + META_EXTENSION;
-		public const string GENERATED_FOLDER_NAME = "Generated";
 		public const string UNITY_PACKAGE_NAME_FORMAT = "{0}_v{1}.unityPackage";
 		public const char EMPTY_SPACE = ' ';
 		public const char UNDERSCORE = '_';
@@ -105,6 +104,27 @@ namespace PackageTool
 		public const string PACKAGE_UPDATE_SUCCESS_FORMAT =
 			"[Package Tools] Successfully updated package source for [{0}].";
 
+		public const string PACKAGE_JSON_META_MISSING_FORMAT =
+			"[Package Tools] No meta file was created for [{0}]; it will be missing from the exported package. " +
+			"Run the export again once Unity has finished importing.";
+
+		public const string NO_SOURCE_PATH_ERROR_FORMAT =
+			"[Package Tools] Config [{0}] has no source path set.";
+
+		public const string NO_PACKAGE_DESTINATION_PATH_ERROR_FORMAT =
+			"[Package Tools] Config [{0}] has no package destination path set.";
+
+		public const string NO_LEGACY_DESTINATION_PATH_ERROR_FORMAT =
+			"[Package Tools] Config [{0}] has no legacy package destination path set.";
+
+		public const string CONFIG_NOT_FOUND_ERROR_FORMAT =
+			"[Package Tools] No PackageManifestConfig matches [{0}]. Selectors match the config id, the package " +
+			"name or the asset name.";
+
+		public const string AMBIGUOUS_CONFIG_ERROR_FORMAT =
+			"[Package Tools] Selector [{0}] matches more than one PackageManifestConfig: {1}. Use the config id " +
+			"instead.";
+
 		public const string AGENT_LOCKED_FILE_MARKER_FORMAT =
 			"<!--\n" +
 			"AGENT NOTE: This file is auto-generated and locked for direct edits.\n" +

package/Editor/Inspectors/PackageManifestConfigInspector.cs

@@ -22,6 +22,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
+using System;
 using PackageTool.Tools;
 using UnityEditor;
 using UnityEditorInternal;
@@ -279,17 +280,29 @@ namespace PackageTool.Inspectors
 				    EditorConstants.GENERATE_VERSION_CONSTANTS_BUTTON_TEXT,
 				    EditorConstants.GENERATE_VERSION_CONSTANTS_TOOLTIP)))
 			{
-				CodeGenTools.GenerateVersionConstants(config);
+				RunAction(config, PackageToolApi.GenerateVersionConstants);
 			}
 
 			if (GUILayout.Button(EditorConstants.UPDATE_PACKAGE_BUTTON_TEXT))
 			{
-				FileTools.CreateOrUpdatePackageSource(config);
+				RunAction(config, x => PackageToolApi.ExportPackageSource(x));
 			}
 
 			if (GUILayout.Button(EditorConstants.EXPORT_LEGACY_PACKAGE_BUTTON_TEXT))
 			{
-				UnityFileTools.CompileLegacyPackage(config);
+				RunAction(config, x => PackageToolApi.ExportLegacyPackage(x));
+			}
+		}
+
+		private static void RunAction(PackageManifestConfig config, Func<PackageManifestConfig, string> action)
+		{
+			try
+			{
+				action.Invoke(config);
+			}
+			catch (Exception e)
+			{
+				Debug.LogException(e, config);
 			}
 		}
 

package/Editor/PackageToolApi.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using PackageTool.Tools;
+using UnityEditor;
+
+namespace PackageTool
+{
+	/// <summary>
+	/// Public entry points for driving the package tools from other editor code. Every method throws on
+	/// failure and returns the path of what it produced.
+	/// </summary>
+	public static class PackageToolApi
+	{
+		/// <summary>
+		/// Returns all <see cref="PackageManifestConfig"/> assets in the project.
+		/// </summary>
+		public static PackageManifestConfig[] GetConfigs() => PackageManifestTools.GetAllConfigs();
+
+		/// <summary>
+		/// Returns the <see cref="PackageManifestConfig"/> matching <paramref name="selector"/>, which is
+		/// compared case-insensitively against the config id, the package name and the asset name, in that
+		/// order. Returns null when nothing matches and throws when the selector is ambiguous.
+		/// </summary>
+		/// <param name="selector"></param>
+		public static PackageManifestConfig FindConfig(string selector) => FindConfig(selector, GetConfigs());
+
+		/// <summary>
+		/// Returns the <see cref="PackageManifestConfig"/> matching <paramref name="selector"/> from
+		/// <paramref name="configs"/>. Use this overload to resolve several selectors against a single lookup
+		/// of the project.
+		/// </summary>
+		/// <param name="selector"></param>
+		/// <param name="configs"></param>
+		public static PackageManifestConfig FindConfig(string selector, PackageManifestConfig[] configs)
+		{
+			if (string.IsNullOrEmpty(selector))
+				throw new ArgumentNullException(nameof(selector));
+			if (configs == null)
+				throw new ArgumentNullException(nameof(configs));
+
+			var matches = MatchByField(configs, selector, config => config.Id);
+			if (matches.Count == 0)
+				matches = MatchByField(configs, selector, config => config.packageName);
+			if (matches.Count == 0)
+				matches = MatchByField(configs, selector, config => config.name);
+
+			if (matches.Count > 1)
+			{
+				var candidates = string.Join(", ", matches.Select(x => $"{x.name} ({x.Id})"));
+				throw new InvalidOperationException(
+					string.Format(EditorConstants.AMBIGUOUS_CONFIG_ERROR_FORMAT, selector, candidates));
+			}
+
+			return matches.Count == 1 ? matches[0] : null;
+		}
+
+		/// <summary>
+		/// Returns the <see cref="PackageManifestConfig"/> matching <paramref name="selector"/> and throws
+		/// when no config matches it.
+		/// </summary>
+		/// <param name="selector"></param>
+		public static PackageManifestConfig GetConfig(string selector)
+		{
+			var config = FindConfig(selector);
+			if (config == null)
+				throw new InvalidOperationException(
+					string.Format(EditorConstants.CONFIG_NOT_FOUND_ERROR_FORMAT, selector));
+
+			return config;
+		}
+
+		/// <summary>
+		/// Generates the VersionConstants.cs file for <paramref name="config"/> and returns its path, or null
+		/// when the config has no version constants path set.
+		/// </summary>
+		/// <param name="config"></param>
+		public static string GenerateVersionConstants(PackageManifestConfig config)
+		{
+			if (config == null)
+				throw new ArgumentNullException(nameof(config));
+
+			return CodeGenTools.GenerateVersionConstants(config);
+		}
+
+		/// <summary>
+		/// Exports the package source of <paramref name="config"/> to its
+		/// <see cref="PackageManifestConfig.packageDestinationPath"/> and returns the path of the written
+		/// package.json. When <paramref name="version"/> is set it replaces the version on the config asset
+		/// before the export.
+		/// </summary>
+		/// <param name="config"></param>
+		/// <param name="version"></param>
+		public static string ExportPackageSource(PackageManifestConfig config, string version = null)
+		{
+			if (config == null)
+				throw new ArgumentNullException(nameof(config));
+
+			ApplyVersion(config, version);
+
+			return FileTools.CreateOrUpdatePackageSourceOrThrow(config);
+		}
+
+		/// <summary>
+		/// Exports <paramref name="config"/> as a legacy unity package to its
+		/// <see cref="PackageManifestConfig.legacyPackageDestinationPath"/> and returns the path of the
+		/// written file. When <paramref name="version"/> is set it replaces the version on the config asset
+		/// before the export.
+		/// </summary>
+		/// <param name="config"></param>
+		/// <param name="version"></param>
+		public static string ExportLegacyPackage(PackageManifestConfig config, string version = null)
+		{
+			if (config == null)
+				throw new ArgumentNullException(nameof(config));
+
+			ApplyVersion(config, version);
+
+			return UnityFileTools.CompileLegacyPackage(config);
+		}
+
+		private static void ApplyVersion(PackageManifestConfig config, string version)
+		{
+			if (string.IsNullOrEmpty(version) || config.packageVersion == version)
+				return;
+
+			config.packageVersion = version;
+			EditorUtility.SetDirty(config);
+		}
+
+		private static List<PackageManifestConfig> MatchByField(
+			PackageManifestConfig[] configs,
+			string selector,
+			Func<PackageManifestConfig, string> getField)
+		{
+			return configs
+				.Where(x => string.Compare(getField(x), selector, StringComparison.OrdinalIgnoreCase) == 0)
+				.ToList();
+		}
+	}
+}

package/Editor/PackageToolApi.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0820e17796614bc8932db35ef4afb0ee
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: