@push.rocks/taskbuffer 4.2.1 → 5.0.0

package/dist_ts/taskbuffer.classes.taskmanager.js

@@ -1,5 +1,6 @@
 import * as plugins from './taskbuffer.plugins.js';
 import { Task } from './taskbuffer.classes.task.js';
+import { TaskConstraintGroup } from './taskbuffer.classes.taskconstraintgroup.js';
 import { AbstractDistributedCoordinator, } from './taskbuffer.classes.distributedcoordinator.js';
 import { logger } from './taskbuffer.logging.js';
 export class TaskManager {
@@ -12,6 +13,10 @@ export class TaskManager {
         this.options = {
             distributedCoordinator: null,
         };
+        // Constraint system
+        this.constraintGroups = [];
+        this.constraintQueue = [];
+        this.drainTimer = null;
         this.options = Object.assign(this.options, options);
     }
     getTaskByName(taskName) {
@@ -39,15 +44,106 @@ export class TaskManager {
         this.addTask(task);
         this.scheduleTaskByName(task.name, cronString);
     }
+    // Constraint group management
+    addConstraintGroup(group) {
+        this.constraintGroups.push(group);
+    }
+    removeConstraintGroup(name) {
+        this.constraintGroups = this.constraintGroups.filter((g) => g.name !== name);
+    }
+    // Core constraint evaluation
+    async triggerTaskConstrained(task, input) {
+        // Gather applicable constraints
+        const applicableGroups = [];
+        for (const group of this.constraintGroups) {
+            const key = group.getConstraintKey(task);
+            if (key !== null) {
+                applicableGroups.push({ group, key });
+            }
+        }
+        // No constraints apply → trigger directly
+        if (applicableGroups.length === 0) {
+            return task.trigger(input);
+        }
+        // Check if all constraints allow running
+        const allCanRun = applicableGroups.every(({ group, key }) => group.canRun(key));
+        if (allCanRun) {
+            return this.executeWithConstraintTracking(task, input, applicableGroups);
+        }
+        // Blocked → enqueue with deferred promise
+        const deferred = plugins.smartpromise.defer();
+        this.constraintQueue.push({ task, input, deferred });
+        return deferred.promise;
+    }
+    async executeWithConstraintTracking(task, input, groups) {
+        // Acquire slots
+        for (const { group, key } of groups) {
+            group.acquireSlot(key);
+        }
+        try {
+            return await task.trigger(input);
+        }
+        finally {
+            // Release slots
+            for (const { group, key } of groups) {
+                group.releaseSlot(key);
+            }
+            this.drainConstraintQueue();
+        }
+    }
+    drainConstraintQueue() {
+        let shortestCooldown = Infinity;
+        const stillQueued = [];
+        for (const entry of this.constraintQueue) {
+            const applicableGroups = [];
+            for (const group of this.constraintGroups) {
+                const key = group.getConstraintKey(entry.task);
+                if (key !== null) {
+                    applicableGroups.push({ group, key });
+                }
+            }
+            // No constraints apply anymore (group removed?) → run directly
+            if (applicableGroups.length === 0) {
+                entry.task.trigger(entry.input).then((result) => entry.deferred.resolve(result), (err) => entry.deferred.reject(err));
+                continue;
+            }
+            const allCanRun = applicableGroups.every(({ group, key }) => group.canRun(key));
+            if (allCanRun) {
+                this.executeWithConstraintTracking(entry.task, entry.input, applicableGroups).then((result) => entry.deferred.resolve(result), (err) => entry.deferred.reject(err));
+            }
+            else {
+                stillQueued.push(entry);
+                // Track shortest cooldown for timer scheduling
+                for (const { group, key } of applicableGroups) {
+                    const remaining = group.getCooldownRemaining(key);
+                    if (remaining > 0 && remaining < shortestCooldown) {
+                        shortestCooldown = remaining;
+                    }
+                }
+            }
+        }
+        this.constraintQueue = stillQueued;
+        // Schedule next drain if there are cooldown-blocked entries
+        if (this.drainTimer) {
+            clearTimeout(this.drainTimer);
+            this.drainTimer = null;
+        }
+        if (stillQueued.length > 0 && shortestCooldown < Infinity) {
+            this.drainTimer = setTimeout(() => {
+                this.drainTimer = null;
+                this.drainConstraintQueue();
+            }, shortestCooldown + 1);
+        }
+    }
     async triggerTaskByName(taskName) {
         const taskToTrigger = this.getTaskByName(taskName);
         if (!taskToTrigger) {
             throw new Error(`No task with the name ${taskName} found.`);
         }
-        return taskToTrigger.trigger();
+        return this.triggerTaskConstrained(taskToTrigger);
     }
     async triggerTask(task) {
-        return task.trigger();
+        return this.triggerTaskConstrained(task);
     }
     scheduleTaskByName(taskName, cronString) {
         const taskToSchedule = this.getTaskByName(taskName);
@@ -70,7 +166,7 @@ export class TaskManager {
                 }
             }
             try {
-                await task.trigger();
+                await this.triggerTaskConstrained(task);
             }
             catch (err) {
                 logger.log('error', `TaskManager: scheduled task "${task.name || 'unnamed'}" failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -130,6 +226,10 @@ export class TaskManager {
             subscription.unsubscribe();
         }
         this.taskSubscriptions.clear();
+        if (this.drainTimer) {
+            clearTimeout(this.drainTimer);
+            this.drainTimer = null;
+        }
     }
     // Get metadata for a specific task
     getTaskMetadata(taskName) {
@@ -186,10 +286,9 @@ export class TaskManager {
             this.scheduleTaskByName(task.name, options.schedule);
         }
         const startTime = Date.now();
-        const progressUpdates = [];
         try {
-            // Execute the task
-            const result = await task.trigger();
+            // Execute the task through constraints
+            const result = await this.triggerTaskConstrained(task);
             // Collect execution report
             const report = {
                 taskName: task.name || 'unnamed',
@@ -235,4 +334,4 @@ export class TaskManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taskbuffer.classes.taskmanager.js","sourceRoot":"","sources":["../ts/taskbuffer.classes.taskmanager.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taskbuffer.classes.taskmanager.js","sourceRoot":"","sources":["../ts/taskbuffer.classes.taskmanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/taskbuffer.interfaces.d.ts

@@ -1,4 +1,16 @@
 import type { ITaskStep } from './taskbuffer.classes.taskstep.js';
+import type { Task } from './taskbuffer.classes.task.js';
+export interface ITaskConstraintGroupOptions<TData extends Record<string, unknown> = Record<string, unknown>> {
+    name: string;
+    constraintKeyForTask: (task: Task<any, any, TData>) => string | null | undefined;
+    maxConcurrent?: number;
+    cooldownMs?: number;
+}
+export interface IConstrainedTaskEntry {
+    task: Task<any, any, any>;
+    input: any;
+    deferred: import('@push.rocks/smartpromise').Deferred<any>;
+}
 export interface ITaskMetadata {
     name: string;
     version?: string;

package/dist_ts_web/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/taskbuffer',
-    version: '4.2.1',
+    version: '5.0.0',
     description: 'A flexible task management library supporting TypeScript, allowing for task buffering, scheduling, and execution with dependency management.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsd0JBQXdCO0lBQzlCLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSw4SUFBOEk7Q0FDNUosQ0FBQSJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/taskbuffer",
-  "version": "4.2.1",
+  "version": "5.0.0",
   "private": false,
   "description": "A flexible task management library supporting TypeScript, allowing for task buffering, scheduling, and execution with dependency management.",
   "main": "dist_ts/index.js",

package/readme.hints.md

@@ -1,20 +1,42 @@
 # Taskbuffer Hints
 
+## Task Constraint System (v5.0.0+) — Breaking Changes
+- **`TaskRunner` removed** — replaced by `TaskManager` + `TaskConstraintGroup`
+- **`blockingTasks` removed** from `Task` — use `TaskConstraintGroup` with `maxConcurrent: 1`
+- **`execDelay` removed** from `Task` — use `TaskConstraintGroup` with `cooldownMs`
+- **`finished` promise removed** from `Task` — no longer needed
+- **`Task` generic signature**: `Task<T, TSteps, TData>` (3rd param added for typed data)
+
+### Task.data
+- `Task` constructor accepts optional `data?: TData` (defaults to `{}`)
+- Typed data bag accessible as `task.data`
+
+### TaskConstraintGroup
+- `new TaskConstraintGroup<TData>({ name, constraintKeyForTask, maxConcurrent?, cooldownMs? })`
+- `constraintKeyForTask(task)` returns a string key (constraint applies) or `null` (skip)
+- `maxConcurrent` (default: `Infinity`) — max concurrent tasks per key
+- `cooldownMs` (default: `0`) — minimum ms gap between completions per key
+- Methods: `canRun(key)`, `acquireSlot(key)`, `releaseSlot(key)`, `getCooldownRemaining(key)`, `getRunningCount(key)`, `reset()`
+
+### TaskManager Constraint Integration
+- `manager.addConstraintGroup(group)` / `manager.removeConstraintGroup(name)`
+- `triggerTaskByName()`, `triggerTask()`, `addExecuteRemoveTask()`, cron callbacks all route through `triggerTaskConstrained()`
+- `triggerTaskConstrained(task, input?)` — evaluates constraints, queues if blocked, drains after completion
+- Cooldown-blocked entries auto-drain via timer
+
+### Exported from index.ts
+- `TaskConstraintGroup` class
+- `ITaskConstraintGroupOptions` type
+
 ## Error Handling (v3.6.0+)
 - `Task` now has `catchErrors` constructor option (default: `false`)
 - Default behavior: `trigger()` rejects when taskFunction throws (breaking change from pre-3.6)
 - Set `catchErrors: true` to swallow errors (old behavior) - returns `undefined` on error
 - Error state tracked via `lastError?: Error`, `errorCount: number`, `clearError()`
 - `getMetadata()` status uses all four values: `'idle'` | `'running'` | `'completed'` | `'failed'`
-- All peripheral classes (Taskchain, Taskparallel, TaskRunner, BufferRunner, TaskDebounced, TaskManager) have proper error propagation/handling
+- All peripheral classes (Taskchain, Taskparallel, BufferRunner, TaskDebounced, TaskManager) have proper error propagation/handling
 - `console.log` calls replaced with `logger.log()` throughout
 
-## Breaking API Rename (TaskRunner)
-- `maxParrallelJobs` → `maxParallelJobs`
-- `qeuedTasks` → `queuedTasks`
-- JSDoc typos fixed: "qeue" → "queue", "wether" → "whether", "loose" → "lose"
-- The `setMaxParallelJobs()` parameter also renamed from `maxParrallelJobsArg` to `maxParallelJobsArg`
-
 ## Error Context Improvements
 - **TaskChain**: Errors now wrap the original with context: chain name, failing task name, and task index. Original error preserved via `.cause`
 - **BufferRunner**: When `catchErrors: false`, buffered task errors now reject the trigger promise (via `CycleCounter.informOfCycleError`) instead of silently resolving with `undefined`