t-tasks 2.0.0 → 2.1.1

package/dist/t-tasks.js

@@ -519,31 +519,40 @@ let Task;
 	}
 	_Task.all = all;
 	function any(tasks) {
-		const cell = settleCell();
 		const taskArray = Array.from(tasks);
-		if (taskArray.length < 1) return Task.canceled();
-		const cancel = (error) => taskArray.map((task) => task._cancel(error)).every((r) => r);
-		const list = taskArray.map(() => Maybe.nothing());
-		const resolved = (value) => {
-			cell.resolve(value.map(Either.right));
-			cancel(Maybe.nothing());
-		};
-		const rejected = (error, i) => {
-			list[i] = Maybe.just(error);
-			if (Maybe.everyJust(list)) cell.resolve(Maybe.just(Either.left(list.map((v) => Just.just(v)))));
-		};
-		taskArray.map((task, i) => {
-			return task.matchTap({
-				resolved: (value) => resolved(Maybe.just(value)),
-				rejected: (error) => rejected(error, i),
-				canceled: () => resolved(Maybe.nothing())
+		if (taskArray.length === 0) return Task.rejected([]);
+		return Task.fromCallback((resolve, reject, cancel) => {
+			const errors = taskArray.map(() => Maybe.nothing());
+			let remaining = taskArray.length;
+			const checkAllFailed = () => {
+				remaining--;
+				if (remaining === 0) reject(errors.map((e) => e.match({
+					just: (err) => err,
+					nothing: () => void 0
+				})));
+			};
+			taskArray.forEach((task, i) => {
+				task.matchTap({
+					resolved: (value) => {
+						resolve(value);
+						taskArray.forEach((t) => t.cancel());
+					},
+					rejected: (error) => {
+						errors[i] = Maybe.just(error);
+						checkAllFailed();
+					},
+					canceled: () => {
+						cancel();
+						taskArray.forEach((t) => t.cancel());
+					}
+				});
 			});
-		});
-		return Task.create(cell.promise, cancel);
+			return taskArray;
+		}, (subtasks) => subtasks.forEach((t) => t.cancel()));
 	}
 	_Task.any = any;
 	function limit(task, limitTask) {
-		return Task.any([task, limitTask.chain(Task.canceled)]).chainRejected((errors) => Task.rejected(errors[0]));
+		return Task.any([task, limitTask.chain(Task.canceled)]);
 	}
 	_Task.limit = limit;
 	function repeat(taskFunction) {
@@ -613,29 +622,52 @@ function chainTaskMaybe(parent, op) {
 		else return false;
 	});
 }
-function chainTaskEither(_task, op) {
-	return chainTaskMaybe(_task, (maybe) => maybe.map(op).orMap(Task.canceled).just);
+function mapTaskMaybe(parent, op) {
+	const cell = settleCell();
+	let state = { phase: "parent" };
+	parent._invoke((result) => {
+		state = {
+			phase: "transform",
+			error: null
+		};
+		let value = null;
+		try {
+			value = op(result);
+		} catch (e) {
+			cell.resolve(Maybe.just(Either.left(e)));
+			state = { phase: "closed" };
+			return;
+		}
+		const transformError = state.phase === "transform" ? state.error : null;
+		if (transformError) cell.resolve(transformError.map(Either.left));
+		else cell.resolve(value);
+		state = { phase: "closed" };
+	});
+	return Task.create(cell.promise, (error) => {
+		if (cell.settled()) return false;
+		if (state.phase === "parent") return parent._cancel(error);
+		else if (state.phase === "transform") {
+			state.error = error;
+			return true;
+		} else return false;
+	});
 }
-function mapTaskMaybe(_task, op) {
-	return chainTaskMaybe(_task, (maybe) => {
-		return op(maybe).match({
-			just: (either) => either.match({
-				right: Task.resolved,
-				left: Task.rejected
-			}),
-			nothing: Task.canceled
-		});
+function tapTaskMaybe(parent, op) {
+	parent._invoke((result) => {
+		try {
+			op(result);
+		} catch (e) {
+			reportError(e);
+		}
 	});
+	return parent;
+}
+function chainTaskEither(_task, op) {
+	return chainTaskMaybe(_task, (maybe) => maybe.map(op).orMap(Task.canceled).just);
 }
 function mapTaskEither(_task, op) {
 	return mapTaskMaybe(_task, (maybe) => maybe.map(op));
 }
-function tapTaskMaybe(_task, op) {
-	return mapTaskMaybe(_task, (value) => {
-		op(value);
-		return value;
-	});
-}
 function tapTaskEither(_task, op) {
 	return tapTaskMaybe(_task, (maybe) => maybe.tap(op));
 }
@@ -747,6 +779,9 @@ var TaskClass = class {
 		});
 	}
 };
+function reportError(error) {
+	if (typeof globalThis.reportError === "function") globalThis.reportError(error);
+}
 //#endregion
 Object.defineProperty(exports, "Either", {
 	enumerable: true,