@push.rocks/taskbuffer 3.1.10 → 3.4.0

package/dist_ts_web/ts_web/elements/taskbuffer-dashboard.demo.js

@@ -0,0 +1,285 @@
+import { html, css, cssManager } from '@design.estate/dees-element';
+import { TaskManager, Task } from '../../ts/index.js';
+import '../taskbuffer-dashboard.js';
+export const demoFunc = () => html `
+  <style>
+    ${css `
+      .demoWrapper {
+        box-sizing: border-box;
+        position: relative;
+        width: 100%;
+        min-height: 100vh;
+        padding: 48px;
+        background: ${cssManager.bdTheme('#f8f9fa', '#0a0a0a')};
+      }
+      
+      h1 {
+        font-size: 32px;
+        font-weight: 700;
+        color: ${cssManager.bdTheme('#09090b', '#fafafa')};
+        margin-bottom: 12px;
+        text-align: center;
+      }
+      
+      p {
+        font-size: 16px;
+        color: ${cssManager.bdTheme('#71717a', '#a1a1aa')};
+        text-align: center;
+        margin-bottom: 48px;
+      }
+    `}
+  </style>
+  
+  <div class="demoWrapper">
+    <h1>TaskBuffer Dashboard Demo</h1>
+    <p>Real-time visualization of task execution, progress tracking, and scheduling</p>
+    
+    <dees-demowrapper 
+      .title=${'Live Dashboard'}
+      .subtitle=${'Interactive task management dashboard with real-time updates'}
+      .runAfterRender=${async (element) => {
+    // Create TaskManager instance
+    const taskManager = new TaskManager();
+    // Get dashboard element
+    const dashboard = element.querySelector('taskbuffer-dashboard');
+    dashboard.taskManager = taskManager;
+    dashboard.refreshInterval = 500;
+    // Task counter for unique names
+    let taskCounter = 0;
+    // Helper to create random delay
+    const randomDelay = () => new Promise(resolve => setTimeout(resolve, Math.random() * 2000 + 500));
+    // Add initial demo tasks
+    const addDemoTasks = () => {
+        // Add simple task
+        const simpleTask = new Task({
+            name: `SimpleTask_${++taskCounter}`,
+            taskFunction: async () => {
+                console.log(`Executing SimpleTask_${taskCounter}`);
+                await randomDelay();
+                return `Result from SimpleTask_${taskCounter}`;
+            }
+        });
+        taskManager.addTask(simpleTask);
+        // Add task with steps
+        const steppedTask = new Task({
+            name: `SteppedTask_${++taskCounter}`,
+            steps: [
+                { name: 'init', description: 'Initializing', percentage: 20 },
+                { name: 'fetch', description: 'Fetching data', percentage: 30 },
+                { name: 'process', description: 'Processing', percentage: 35 },
+                { name: 'save', description: 'Saving results', percentage: 15 }
+            ],
+            taskFunction: async function () {
+                this.notifyStep('init');
+                await randomDelay();
+                this.notifyStep('fetch');
+                await randomDelay();
+                this.notifyStep('process');
+                await randomDelay();
+                this.notifyStep('save');
+                await randomDelay();
+                return `Completed SteppedTask_${taskCounter}`;
+            }
+        });
+        taskManager.addTask(steppedTask);
+        // Add buffered task
+        const bufferedTask = new Task({
+            name: `BufferedTask_${++taskCounter}`,
+            buffered: true,
+            bufferMax: 3,
+            steps: [
+                { name: 'buffer', description: 'Processing buffered item', percentage: 100 }
+            ],
+            taskFunction: async function (item) {
+                this.notifyStep('buffer');
+                console.log(`Processing buffered item: ${item}`);
+                await randomDelay();
+                return `Buffered task ${taskCounter} processed: ${item}`;
+            }
+        });
+        taskManager.addTask(bufferedTask);
+    };
+    // Add initial tasks
+    addDemoTasks();
+    // Automatically trigger some tasks
+    setTimeout(() => {
+        const tasks = taskManager.getAllTasksMetadata();
+        tasks.forEach(taskMeta => {
+            const task = taskManager.getTaskByName(taskMeta.name);
+            if (task && !taskMeta.name.includes('Scheduled')) {
+                if (taskMeta.buffered) {
+                    // Trigger buffered task multiple times
+                    for (let i = 0; i < 5; i++) {
+                        task.trigger(`Data_${i}`);
+                    }
+                }
+                else {
+                    task.trigger();
+                }
+            }
+        });
+    }, 2000);
+}}
+    >
+      <taskbuffer-dashboard></taskbuffer-dashboard>
+    </dees-demowrapper>
+    
+    <dees-demowrapper
+      .title=${'Scheduled Tasks'}
+      .subtitle=${'Tasks scheduled with cron expressions'}
+      .runAfterRender=${async (element) => {
+    // Create TaskManager instance
+    const taskManager = new TaskManager();
+    // Get dashboard element
+    const dashboard = element.querySelector('taskbuffer-dashboard');
+    dashboard.taskManager = taskManager;
+    dashboard.refreshInterval = 1000;
+    // Add scheduled tasks
+    const scheduledTask1 = new Task({
+        name: 'HourlyBackup',
+        steps: [
+            { name: 'prepare', description: 'Preparing backup', percentage: 30 },
+            { name: 'backup', description: 'Creating backup', percentage: 50 },
+            { name: 'verify', description: 'Verifying backup', percentage: 20 }
+        ],
+        taskFunction: async function () {
+            this.notifyStep('prepare');
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            this.notifyStep('backup');
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            this.notifyStep('verify');
+            await new Promise(resolve => setTimeout(resolve, 500));
+            return 'Backup completed';
+        }
+    });
+    const scheduledTask2 = new Task({
+        name: 'DailyReport',
+        steps: [
+            { name: 'collect', description: 'Collecting data', percentage: 40 },
+            { name: 'analyze', description: 'Analyzing data', percentage: 40 },
+            { name: 'send', description: 'Sending report', percentage: 20 }
+        ],
+        taskFunction: async function () {
+            this.notifyStep('collect');
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            this.notifyStep('analyze');
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            this.notifyStep('send');
+            await new Promise(resolve => setTimeout(resolve, 500));
+            return 'Report sent';
+        }
+    });
+    // Schedule tasks
+    taskManager.addAndScheduleTask(scheduledTask1, '0 * * * *'); // Every hour
+    taskManager.addAndScheduleTask(scheduledTask2, '0 0 * * *'); // Daily at midnight
+    // Also add them as regular tasks for demo
+    const demoTask = new Task({
+        name: 'DemoScheduledExecution',
+        steps: [
+            { name: 'execute', description: 'Simulating scheduled execution', percentage: 100 }
+        ],
+        taskFunction: async function () {
+            this.notifyStep('execute');
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            // Trigger scheduled tasks for demo
+            scheduledTask1.trigger();
+            scheduledTask2.trigger();
+            return 'Triggered scheduled tasks for demo';
+        }
+    });
+    taskManager.addTask(demoTask);
+    // Trigger demo after 2 seconds
+    setTimeout(() => {
+        demoTask.trigger();
+    }, 2000);
+}}
+    >
+      <taskbuffer-dashboard></taskbuffer-dashboard>
+    </dees-demowrapper>
+    
+    <dees-demowrapper
+      .title=${'Task Execution Control'}
+      .subtitle=${'Interactive controls for task management'}
+      .runAfterRender=${async (element) => {
+    // Create TaskManager instance
+    const taskManager = new TaskManager();
+    // Get dashboard element
+    const dashboard = element.querySelector('taskbuffer-dashboard');
+    dashboard.taskManager = taskManager;
+    dashboard.refreshInterval = 300;
+    // Add control buttons
+    const controlsDiv = document.createElement('div');
+    controlsDiv.style.cssText = `
+          display: flex;
+          gap: 8px;
+          margin-bottom: 16px;
+          flex-wrap: wrap;
+        `;
+    const createButton = (text, onClick, style = '') => {
+        const button = document.createElement('button');
+        button.textContent = text;
+        button.style.cssText = `
+            padding: 8px 16px;
+            border: none;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 14px;
+            transition: all 0.2s;
+            ${style}
+          `;
+        button.onclick = onClick;
+        return button;
+    };
+    let taskCounter = 0;
+    // Add task button
+    controlsDiv.appendChild(createButton('Add Task', () => {
+        const task = new Task({
+            name: `Task_${++taskCounter}`,
+            steps: [
+                { name: 'step1', description: 'Step 1', percentage: 33 },
+                { name: 'step2', description: 'Step 2', percentage: 33 },
+                { name: 'step3', description: 'Step 3', percentage: 34 }
+            ],
+            taskFunction: async function () {
+                for (const step of ['step1', 'step2', 'step3']) {
+                    this.notifyStep(step);
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                }
+                return `Task_${taskCounter} completed`;
+            }
+        });
+        taskManager.addTask(task);
+    }, 'background: #3b82f6; color: white;'));
+    // Trigger all button
+    controlsDiv.appendChild(createButton('Trigger All', () => {
+        const tasks = taskManager.getAllTasksMetadata();
+        tasks.forEach(taskMeta => {
+            const task = taskManager.getTaskByName(taskMeta.name);
+            if (task) {
+                task.trigger();
+            }
+        });
+    }, 'background: #22c55e; color: white;'));
+    // Clear all button
+    controlsDiv.appendChild(createButton('Clear All', () => {
+        const tasks = taskManager.getAllTasksMetadata();
+        tasks.forEach(taskMeta => {
+            const task = taskManager.getTaskByName(taskMeta.name);
+            if (task) {
+                taskManager.taskMap.remove(task);
+                taskManager.descheduleTaskByName(taskMeta.name);
+            }
+        });
+    }, 'background: #ef4444; color: white;'));
+    element.insertBefore(controlsDiv, dashboard);
+    // Add some initial tasks
+    for (let i = 0; i < 3; i++) {
+        controlsDiv.querySelector('button').click();
+    }
+}}
+    >
+      <taskbuffer-dashboard></taskbuffer-dashboard>
+    </dees-demowrapper>
+  </div>
+`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taskbuffer-dashboard.demo.js","sourceRoot":"","sources":["../../../ts_web/elements/taskbuffer-dashboard.demo.ts"],"names":[],"mappings":"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"}

package/dist_ts_web/ts_web/index.d.ts

@@ -0,0 +1,2 @@
+export * from './taskbuffer-dashboard.js';
+export type { TaskManager, Task, ITaskMetadata, ITaskExecutionReport, IScheduledTaskInfo, ITaskStep } from '../ts/index.js';

package/dist_ts_web/ts_web/index.js

@@ -0,0 +1,3 @@
+// Export web components
+export * from './taskbuffer-dashboard.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c193ZWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsd0JBQXdCO0FBQ3hCLGNBQWMsMkJBQTJCLENBQUMifQ==

package/dist_ts_web/ts_web/taskbuffer-dashboard.d.ts

@@ -0,0 +1,24 @@
+import { DeesElement } from '@design.estate/dees-element';
+import type { TaskManager } from '../ts/index.js';
+/**
+ * A web component that displays TaskManager tasks with progress visualization
+ */
+export declare class TaskbufferDashboard extends DeesElement {
+    taskManager: TaskManager | null;
+    refreshInterval: number;
+    private tasks;
+    private scheduledTasks;
+    private isRunning;
+    private refreshTimer;
+    static styles: import("@design.estate/dees-element").CSSResult[];
+    connectedCallback(): Promise<void>;
+    disconnectedCallback(): Promise<void>;
+    private startRefreshing;
+    private stopRefreshing;
+    private updateData;
+    private formatNextRun;
+    private formatDuration;
+    render(): import("@design.estate/dees-element").TemplateResult<1>;
+    private renderTaskCard;
+    private renderScheduledTaskCard;
+}