feat(tasks): Support for having dependency tasks (#71)

* Better error handling when bundling scripts fails

* Refactor runTask signature

* Add support for reading assets in tasks and refactor TaskBundleScripts with the new system

* Remove dependencyAssets property

* Use new writeAssets property for TaskGenerateServices

* Support for running dependency tasks when requesting generated file assets

* Lint

Author: jespertheend

editor/dist/css.css

@@ -148,8 +148,8 @@ body, html{
 
 .project-selector-logo {
 	background: url(img/logo.svg) no-repeat center;
-	width: 100px;
-	height: 100px;
+	width: 169px;
+	height: 206px;
 }
 
 .project-selector-title {

editor/src/assets/AssetManager.js

@@ -69,7 +69,18 @@ import {InternallyCreatedAsset} from "./InternallyCreatedAsset.js";
  * 			TLiveAsset :
  * 			never :
  * 		never :
- * 	never} AssertionOptionsToLiveAsset
+ * 	never} AssetAssertionOptionsToLiveAsset
+ */
+
+/**
+ * @template {AssetAssertionOptions} T
+ * @typedef {AssetAssertionOptionsToProjectAsset<T> extends infer ProjectAsset ?
+ * 	ProjectAsset extends import("./ProjectAsset.js").ProjectAsset<infer ProjectAssetType> ?
+ * 		ProjectAssetType extends import("./projectAssetType/ProjectAssetType.js").ProjectAssetType<any, any, infer TFileData, any> ?
+ * 			TFileData :
+ * 			never :
+ * 		never :
+ * 	never} AssetAssertionOptionsToReadAssetDataReturn
  */
 
 /** @typedef {(granted: boolean) => void} OnPermissionPromptResultCallback */
@@ -295,6 +306,10 @@ export class AssetManager {
 	}
 
 	/**
+	 * Creates a new asset at the specified directory.
+	 * The name of the file is determined by the asset type and if an asset
+	 * already exists a different name will be chosen for the new asset.
+	 * If you wish to create an asset with a specific name, use {@linkcode registerAsset}.
 	 * @param {string[]} parentPath
 	 * @param {string} assetType
 	 */
@@ -417,7 +432,9 @@ export class AssetManager {
 	 * @param {import("../util/fileSystems/EditorFileSystem.js").FileSystemExternalChangeEvent} e
 	 */
 	async externalChange(e) {
-		const projectAsset = await this.getProjectAssetFromPath(e.path, this.assetSettingsLoaded);
+		const projectAsset = await this.getProjectAssetFromPath(e.path, {
+			registerIfNecessary: this.assetSettingsLoaded,
+		});
 		if (projectAsset) {
 			const guessedType = await ProjectAsset.guessAssetTypeFromFile(this.builtInAssetManager, this.projectAssetTypeManager, this.fileSystem, e.path);
 			if (guessedType != projectAsset.assetType) {
@@ -548,7 +565,6 @@ export class AssetManager {
 		if (!projectAsset) return null;
 		if (assertAssetType) {
 			const projectAssetTypeConstructor = await projectAsset.getProjectAssetTypeConstructor();
-
 			AssetManager.assertProjectAssetIsType(projectAssetTypeConstructor, assertAssetType);
 		}
 		return /** @type {AssetAssertionOptionsToProjectAsset<T>} */ (projectAsset);
@@ -609,21 +625,33 @@ export class AssetManager {
 	}
 
 	/**
+	 * @template {AssetAssertionOptions} [T = {}]
 	 * @param {string[]} path
-	 * @param {boolean} registerIfNecessary
+	 * @param {Object} options
+	 * @param {boolean} [options.registerIfNecessary]
+	 * @param {T?} [options.assertionOptions]
 	 */
-	async getProjectAssetFromPath(path, registerIfNecessary = true) {
+	async getProjectAssetFromPath(path, {
+		registerIfNecessary = true,
+		assertionOptions = null,
+	} = {}) {
 		await this.loadAssetSettings(true);
+		let projectAsset = null;
 		for (const asset of this.projectAssets.values()) {
 			if (AssetManager.testPathMatch(path, asset.path)) {
-				return asset;
+				projectAsset = asset;
+				break;
 			}
 		}
 
-		if (registerIfNecessary && await this.fileSystem.isFile(path)) {
-			return await this.registerAsset(path);
+		if (!projectAsset && registerIfNecessary && await this.fileSystem.isFile(path)) {
+			projectAsset = await this.registerAsset(path);
 		}
-		return null;
+		if (projectAsset && assertionOptions?.assertAssetType) {
+			const projectAssetTypeConstructor = await projectAsset.getProjectAssetTypeConstructor();
+			AssetManager.assertProjectAssetIsType(projectAssetTypeConstructor, assertionOptions.assertAssetType);
+		}
+		return /** @type {AssetAssertionOptionsToProjectAsset<T>?} */ (projectAsset);
 	}
 
 	/**
@@ -656,14 +684,14 @@ export class AssetManager {
 	 * @template {AssetAssertionOptions} [T = {}]
 	 * @param {import("../../../src/mod.js").UuidString?} uuid
 	 * @param {T} [assertionOptions]
-	 * @returns {Promise<AssertionOptionsToLiveAsset<T>?>}
+	 * @returns {Promise<AssetAssertionOptionsToLiveAsset<T>?>}
 	 */
 	async getLiveAsset(uuid, assertionOptions) {
 		const projectAsset = await this.getProjectAssetFromUuid(uuid, assertionOptions);
 		if (!projectAsset) return null;
 
 		const liveAsset = await projectAsset.getLiveAsset();
-		return /** @type {AssertionOptionsToLiveAsset<T>} */ (liveAsset);
+		return /** @type {AssetAssertionOptionsToLiveAsset<T>} */ (liveAsset);
 	}
 
 	/**
@@ -895,12 +923,12 @@ export class AssetManager {
 	 * @template {GetLiveAssetFromUuidOrEmbeddedAssetDataOptions} T
 	 * @param {import("../../../src/mod.js").UuidString | object | null | undefined} uuidOrData
 	 * @param {T} options
-	 * @returns {Promise<AssertionOptionsToLiveAsset<T>?>}
+	 * @returns {Promise<AssetAssertionOptionsToLiveAsset<T>?>}
 	 */
 	async getLiveAssetFromUuidOrEmbeddedAssetData(uuidOrData, options) {
 		const projectAsset = await this.getProjectAssetFromUuidOrEmbeddedAssetData(uuidOrData, options);
 		if (!projectAsset) return null;
 		const liveAsset = await projectAsset.getLiveAsset();
-		return /** @type {AssertionOptionsToLiveAsset<T>} */ (liveAsset);
+		return /** @type {AssetAssertionOptionsToLiveAsset<T>} */ (liveAsset);
 	}
 }

editor/src/assets/liveAssetDataRecursionTracker/RecursionTracker.js

@@ -137,13 +137,13 @@ export class RecursionTracker {
 	/**
 	 * @template {GetLiveAssetDataOptions} [T = {}]
 	 * @param {import("../../../../src/util/mod.js").UuidString} uuid
-	 * @param {(liveAsset: import("../AssetManager.js").AssertionOptionsToLiveAsset<T>?) => void} cb
+	 * @param {(liveAsset: import("../AssetManager.js").AssetAssertionOptionsToLiveAsset<T>?) => void} cb
 	 * @param {T} options
 	 */
 	getLiveAsset(uuid, cb, options = /** @type {T} */ ({})) {
 		this.getLiveAssetData(uuid, liveAssetData => {
 			const liveAsset = liveAssetData?.liveAsset ?? null;
-			const castLiveAsset = /** @type {import("../AssetManager.js").AssertionOptionsToLiveAsset<T>?} */ (liveAsset);
+			const castLiveAsset = /** @type {import("../AssetManager.js").AssetAssertionOptionsToLiveAsset<T>?} */ (liveAsset);
 			cb(castLiveAsset);
 		}, options);
 	}

editor/src/assets/projectAssetType/ProjectAssetTypeJavascript.js

@@ -8,9 +8,8 @@ import {getEditorInstance} from "../../editorInstance.js";
  * @property {boolean} useClosureCompiler
  */
 
-// todo: better types for generics
 /**
- * @extends {ProjectAssetType<null, null, any, AssetBundleDiskDataProjectAssetTypeJavascriptAssetSettings>}
+ * @extends {ProjectAssetType<null, null, string, AssetBundleDiskDataProjectAssetTypeJavascriptAssetSettings>}
  */
 export class ProjectAssetTypeJavascript extends ProjectAssetType {
 	static type = "renda:javascript";

editor/src/propertiesAssetContent/PropertiesAssetContentTask.js

@@ -27,10 +27,7 @@ export class PropertiesAssetContentTask extends PropertiesAssetContent {
 				text: "Run Task",
 				onClick: async () => {
 					for (const asset of this.currentSelection) {
-						const assetContent = await asset.readAssetData();
-						this.editorInstance.taskManager.runTask({
-							taskFileContent: assetContent,
-						});
+						this.editorInstance.taskManager.runTask(asset);
 					}
 				},
 			},

editor/src/tasks/TaskManager.js

@@ -2,12 +2,29 @@ import {getEditorInstance} from "../editorInstance.js";
 import {autoRegisterTaskTypes} from "./autoRegisterTaskTypes.js";
 import {Task} from "./task/Task.js";
 
+/**
+ * @typedef {<T extends import("../assets/AssetManager.js").AssetAssertionOptions>(path: import("../util/fileSystems/EditorFileSystem.js").EditorFileSystemPath, assertionOptions: T) => Promise<import("../assets/AssetManager.js").AssetAssertionOptionsToReadAssetDataReturn<T>?>} ReadAssetFromPathSignature
+ */
+
+/**
+ * @typedef {<T extends import("../assets/AssetManager.js").AssetAssertionOptions>(uuid: import("../../../src/mod.js").UuidString, assertionOptions: T) => Promise<import("../assets/AssetManager.js").AssetAssertionOptionsToReadAssetDataReturn<T>?>} ReadAssetFromUuidSignature
+ */
+
 export class TaskManager {
 	/** @type {Map<string, typeof import("./task/Task.js").Task>} */
 	#registeredTasks = new Map();
 	/** @type {Map<string, Task>} */
 	#initializedTasks = new Map();
 
+	/** @typedef {import("../assets/ProjectAsset.js").ProjectAsset<import("../assets/projectAssetType/ProjectAssetTypeTask.js").ProjectAssetTypeTask>} TaskProjectAsset */
+
+	/**
+	 * This keeps track of which files were generated by which tasks.
+	 * This is to run child tasks in case a task has one of these files as a dependency.
+	 * @type {WeakMap<import("../assets/ProjectAsset.js").ProjectAssetAny, TaskProjectAsset>}
+	 */
+	#touchedTaskAssets = new WeakMap();
+
 	init() {
 		for (const task of autoRegisterTaskTypes) {
 			this.registerTaskType(task);
@@ -65,12 +82,64 @@ export class TaskManager {
 
 	/**
 	 * Runs a task with a specified configuration in a worker.
-	 * @param {Object} options
-	 * @param {import("../assets/projectAssetType/ProjectAssetTypeTask.js").TaskProjectAssetDiskData} options.taskFileContent
-	 * The content of the task file to run.
+	 * @param {TaskProjectAsset} taskAsset The task asset to run.
 	 */
-	async runTask({taskFileContent}) {
+	async runTask(taskAsset) {
+		const taskFileContent = await taskAsset.readAssetData();
 		const taskType = this.initializeTask(taskFileContent.taskType);
-		return await taskType.runTask(taskFileContent.taskConfig);
+		const assetManager = getEditorInstance().projectManager.assetManager;
+
+		/**
+		 * @template T
+		 * @param {import("../assets/ProjectAsset.js").ProjectAsset<import("../assets/AssetManager.js").AssetAssertionOptionsToProjectAssetType<T>>?} asset
+		 */
+		const runDependencyTasksAndRead = async asset => {
+			if (!asset) return null;
+			const taskAsset = this.#touchedTaskAssets.get(asset);
+			if (taskAsset) {
+				await this.runTask(taskAsset);
+			}
+			const result = await asset?.readAssetData();
+			return result || null;
+		};
+
+		const result = await taskType.runTask({
+			config: taskFileContent.taskConfig,
+			needsAllGeneratedAssets: false,
+			async readAssetFromPath(path, assertionOptions) {
+				const asset = await assetManager?.getProjectAssetFromPath(path, {assertionOptions}) || null;
+				return await runDependencyTasksAndRead(asset);
+			},
+			async readAssetFromUuid(uuid, assertionOptions) {
+				const asset = await assetManager?.getProjectAssetFromUuid(uuid, assertionOptions) || null;
+				return await runDependencyTasksAndRead(asset);
+			},
+		});
+
+		if (result.writeAssets) {
+			for (const writeAssetData of result.writeAssets) {
+				if (!assetManager) {
+					throw new Error("Failed to write files from task, asset manager is not available.");
+				}
+				// TODO: Assert that the asset has the correct type. #67
+				let asset = await assetManager.getProjectAssetFromPath(writeAssetData.path);
+				if (!asset) {
+					asset = await assetManager.registerAsset(writeAssetData.path, writeAssetData.assetType);
+				}
+				await asset.writeAssetData(/** @type {Object} **/ (writeAssetData.fileData));
+				this.#touchedTaskAssets.set(asset, taskAsset);
+			}
+		}
+		if (result.touchedAssets) {
+			if (!assetManager) {
+				throw new Error("Failed to register touched assets, asset manager is not available.");
+			}
+			for (const assetUuid of result.touchedAssets) {
+				const asset = await assetManager.getProjectAssetFromUuid(assetUuid);
+				if (asset) {
+					this.#touchedTaskAssets.set(asset, taskAsset);
+				}
+			}
+		}
 	}
 }

editor/src/tasks/task/Task.js

@@ -1,8 +1,41 @@
-
 /**
  * @typedef {new (...args: ConstructorParameters<typeof Task>) => Task} TaskConstructor
  */
 
+/**
+ * @typedef RunTaskReturn
+ * @property {RunTaskCreateAssetData[]} [writeAssets] A list of assets that this task should create when done running.
+ * This is useful if you want to modify files in a very basic way. The assets will be created and written to the output location.
+ * If the task is run programmatically, nothing is written and the program running the task can handle the result accordingly.
+ * Note that if you are not writing some assets as a result of caching, but might write them in the future, you should add them to the `touchedAssets` list.
+ * This way other tasks can trigger this task to run if it depends on them.
+ * If you need more control over how assets are written, such as writing to a file stream, you can write them manually using
+ * the current editor file system. But be sure to list the changed assets in `touchedAssets` as well. Though when using this
+ * method, the task won't be able to be used programmatically. Unless you handle this case specifically when the `needsAlltouchedAssets`
+ * flag is set to true.
+ * @property {import("../../../../src/mod.js").UuidString[]} [touchedAssets] A list of assets that this task touched, or
+ * might touch when the task is run a second time. This is used by other tasks for determining if this task needs to run before them.
+ */
+
+/**
+ * @typedef RunTaskCreateAssetData
+ * @property {import("../../util/fileSystems/EditorFileSystem.js").EditorFileSystemPath} path
+ * @property {string} assetType
+ * @property {import("../../util/fileSystems/EditorFileSystem.js").AllowedWriteFileTypes} fileData
+ */
+
+/**
+ * @template TTaskConfig
+ * @typedef RunTaskOptions
+ * @property {TTaskConfig} config
+ * @property {boolean} needsAllGeneratedAssets If true, running this task was triggered programmatically.
+ * In this case the task should not write any assets to disk and return the changes in `writeAssets` instead.
+ * @property {import("../TaskManager.js").ReadAssetFromPathSignature} readAssetFromPath Reads an asset from the file system.
+ * If the asset was built by another task, the other task will run first in order to update the asset.
+ * @property {import("../TaskManager.js").ReadAssetFromUuidSignature} readAssetFromUuid Reads an asset from the file system.
+ * If the asset was built by another task, the other task will run first in order to update the asset.
+ */
+
 /**
  * @template [TTaskConfig = unknown]
  */
@@ -58,10 +91,10 @@ export class Task {
 	}
 
 	/**
-	 * @param {TTaskConfig} config
-	 * @returns {Promise<unknown>}
+	 * @param {RunTaskOptions<TTaskConfig>} options
+	 * @returns {Promise<RunTaskReturn>}
 	 */
-	async runTask(config) {
+	async runTask(options) {
 		throw new Error(`Task "${this.constructor.name}" does not implement runTask().`);
 	}
 }

editor/src/tasks/task/TaskBundleAssets.js

@@ -158,9 +158,9 @@ export class TaskBundleAssets extends Task {
 	}
 
 	/**
-	 * @param {TaskBundleAssetsConfig} config
+	 * @param {import("./Task.js").RunTaskOptions<TaskBundleAssetsConfig>} config
 	 */
-	async runTask(config) {
+	async runTask({config}) {
 		const fileSystem = this.editorInstance.projectManager.currentProjectFileSystem;
 		if (!fileSystem) {
 			throw new Error("Failed to create Bundle Scripts task: no project file system.");
@@ -197,5 +197,7 @@ export class TaskBundleAssets extends Task {
 		this.#fileStreams.set(fileStreamId, bundleFileStream);
 
 		await this.#messenger.send("bundle", Array.from(assetUuids), fileStreamId);
+
+		return {};
 	}
 }