feat: allow combine task and recreate util to take a Task.Record retu…

…rning function

src/tasks/aggregate/combine.ts

@@ -4,6 +4,7 @@ import { run } from '../../utils/run';
 import { recreate } from '../../utils/recreate';
 import { context } from '../transform/context';
 import { series } from './series';
+import { NullaryFn } from 'type-core';
 import { shallow } from 'merge-strategies';
 import { into } from 'pipettes';
 
@@ -35,7 +36,7 @@ export interface CombineOptions {
  * @returns Task
  */
 export function combine(
-  tasks: Task.Record,
+  tasks: Task.Record | NullaryFn<Task.Record>,
   options?: CombineOptions
 ): Task.Async {
   return async (ctx: Context): Promise<void> => {
@@ -45,8 +46,7 @@ export function combine(
     );
 
     return into(
-      tasks,
-      recreate.bind(null, (task, route) => {
+      recreate(tasks, (task, route) => {
         return context(
           (ctx) => ({ ...ctx, route: ctx.route.concat(route) }),
           task

src/utils/recreate.ts

@@ -1,14 +1,52 @@
 import { Task } from '../definitions';
-import { Empty } from 'type-core';
+import { context } from '../tasks/transform/context';
+import { announce } from '../tasks/transform/announce';
+import { Empty, NullaryFn, TypeGuard } from 'type-core';
+import { shallow } from 'merge-strategies';
+import { into } from 'pipettes';
+
+export interface RecreateOptions {
+  /**
+   * Fixes current routes for tasks according to their
+   * current paths, so they won't be dinamically reassigned.
+   */
+  fix?: boolean;
+  /**
+   * Prints routes before execution for all tasks.
+   */
+  announce?: boolean;
+}
+
+export interface RecreateMap {
+  (task: Task, route: string[]): Task | Empty;
+}
 
 /**
  * Maps all tasks in a `Task.Record`.
  */
 export function recreate(
-  map: (task: Task, route: string[]) => Task | Empty,
-  tasks: Task.Record
+  tasks: Task.Record | NullaryFn<Task.Record>,
+  options?: RecreateOptions | RecreateMap
 ): Task.Record {
-  return recreateHelper([], tasks, map);
+  const record = TypeGuard.isFunction(tasks) ? tasks() : tasks;
+
+  if (TypeGuard.isEmpty(options)) {
+    return record;
+  } else if (TypeGuard.isFunction(options)) {
+    return recreateHelper([], record, options);
+  } else {
+    const opts: RecreateOptions = shallow(
+      { fix: false, announce: false },
+      options || undefined
+    );
+    return recreateHelper([], record, (task, route) => {
+      return into(
+        task,
+        (task) => (opts.announce ? announce(task) : task),
+        (task) => (opts.fix ? context({ route }, task) : task)
+      );
+    });
+  }
 }
 
 function recreateHelper(