@pb33f/cowboy-components 0.7.17 → 0.8.0

package/dist/controllers/global-task-controller.js

@@ -0,0 +1,352 @@
+import { TaskAction } from "../model/task.js";
+import { GlobalTaskService } from "../services/global-task-service.js";
+import { QueuePrefix, TaskStreamChannel } from "../model/channels.js";
+import { ConsoleMessageType } from "../components/terminal-emulator/terminal-emulator.js";
+import { TaskMockGenerator } from "../mocks/task-mock-generator.js";
+import { ToastType } from "../model/toast.js";
+export class GlobalTaskController extends EventTarget {
+    constructor(deps) {
+        super();
+        this.taskStreamSubscription = null;
+        this.tasks = new Map();
+        this.view = null;
+        this.consoleMessages = [];
+        this.mockMode = false;
+        this.mockGenerator = null;
+        this.taskCallbacks = new Map();
+        this.typeSubscriptions = new Map();
+        this.pendingTimeouts = new Set();
+        this.deps = deps;
+        this.bus = deps.bus;
+    }
+    setView(view) {
+        this.view = view;
+    }
+    init() {
+        if (!this.mockMode) {
+            this.taskStreamChannel = this.bus.createChannel(TaskStreamChannel);
+            const handler = this.taskStreamHandler();
+            this.taskStreamSubscription = this.taskStreamChannel.subscribe(handler);
+            this.bus.mapChannelToBrokerDestination(QueuePrefix + TaskStreamChannel, TaskStreamChannel);
+            this.loadInitialTasks();
+        }
+    }
+    enableMockMode() {
+        this.mockMode = true;
+        if (!this.mockGenerator) {
+            this.mockGenerator = new TaskMockGenerator((message) => this.handleTaskMessage(message), (consoleMessage) => this.addConsoleMessage(consoleMessage));
+        }
+        this.mockGenerator.start();
+    }
+    disableMockMode() {
+        this.mockMode = false;
+        if (this.mockGenerator) {
+            this.mockGenerator.stop();
+        }
+        this.tasks.clear();
+        this.consoleMessages = [];
+        this.updateView();
+    }
+    async loadInitialTasks() {
+        try {
+            const response = await GlobalTaskService.getActiveTasks(this.deps.getBrokerId());
+            if (response.response) {
+                const taskList = response.response;
+                taskList.tasks.forEach(task => {
+                    this.processTask(task);
+                });
+                this.updateView();
+            }
+        }
+        catch (error) {
+            console.error('Failed to load initial tasks:', error);
+        }
+    }
+    taskStreamHandler() {
+        return (msg) => {
+            if (msg.payload) {
+                // The Ranch bus wraps the message, so the actual TaskMessage is at msg.payload.payload
+                const wrappedMessage = msg.payload;
+                if (wrappedMessage.payload) {
+                    const taskMessage = wrappedMessage.payload;
+                    this.handleTaskMessage(taskMessage);
+                }
+                else {
+                    console.warn('[GlobalTaskController] Message payload has unexpected structure:', msg.payload);
+                }
+            }
+            else {
+                console.warn('[GlobalTaskController] Message has no payload:', msg);
+            }
+        };
+    }
+    handleTaskMessage(message) {
+        const task = message.task;
+        switch (message.action) {
+            case TaskAction.Create:
+                this.addTask(task);
+                this.addConsoleMessage({
+                    type: ConsoleMessageType.Info,
+                    message: `Task started: ${task.name}`,
+                    timestamp: new Date().toISOString(),
+                    metadata: {
+                        taskId: task.id,
+                        type: task.type
+                    }
+                });
+                break;
+            case TaskAction.Update:
+                this.updateTask(task);
+                if (task.message) {
+                    this.addConsoleMessage({
+                        type: ConsoleMessageType.Info,
+                        message: task.message,
+                        timestamp: new Date().toISOString(),
+                        metadata: {
+                            taskId: task.id,
+                            progress: task.progress || `${task.currentStep}/${task.totalSteps}`
+                        }
+                    });
+                }
+                break;
+            case TaskAction.Complete:
+                this.completeTask(task);
+                this.addConsoleMessage({
+                    type: ConsoleMessageType.Success,
+                    message: `Task completed: ${task.name}`,
+                    timestamp: new Date().toISOString(),
+                    metadata: {
+                        taskId: task.id,
+                        duration: this.formatDuration(task.startedAt, task.completedAt)
+                    }
+                });
+                this.deps.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.SUCCESS,
+                    title: 'Task completed',
+                    body: task.name
+                });
+                this.triggerTaskCallbacks(task.id, task);
+                this.notifyTypeSubscribers(task, TaskAction.Complete);
+                const completeTimeoutId = window.setTimeout(() => {
+                    this.pendingTimeouts.delete(completeTimeoutId);
+                    this.removeTask(task.id);
+                }, 30000);
+                this.pendingTimeouts.add(completeTimeoutId);
+                break;
+            case TaskAction.Fail:
+                this.failTask(task);
+                this.addConsoleMessage({
+                    type: ConsoleMessageType.Error,
+                    message: `Task failed: ${task.name} - ${task.error}`,
+                    timestamp: new Date().toISOString(),
+                    metadata: {
+                        taskId: task.id,
+                        error: task.error
+                    }
+                });
+                this.deps.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.ERROR,
+                    title: 'Task failed',
+                    body: `${task.name}: ${task.error || 'Unknown error'}`
+                });
+                this.triggerTaskCallbacks(task.id, task);
+                this.notifyTypeSubscribers(task, TaskAction.Fail);
+                const failTimeoutId = window.setTimeout(() => {
+                    this.pendingTimeouts.delete(failTimeoutId);
+                    this.removeTask(task.id);
+                }, 60000);
+                this.pendingTimeouts.add(failTimeoutId);
+                break;
+        }
+        this.updateView();
+    }
+    processTask(task) {
+        if (task.subtasks) {
+            task.subtasks.forEach(subtask => {
+                this.tasks.set(subtask.id, subtask);
+            });
+        }
+        this.tasks.set(task.id, task);
+    }
+    addTask(task) {
+        this.processTask(task);
+        this.updateView();
+    }
+    updateTask(task) {
+        const existingTask = this.tasks.get(task.id);
+        if (existingTask) {
+            Object.assign(existingTask, task);
+        }
+        else {
+            this.processTask(task);
+        }
+        this.updateView();
+    }
+    completeTask(task) {
+        const existingTask = this.tasks.get(task.id);
+        if (existingTask) {
+            existingTask.status = 'completed';
+            existingTask.progress = 100;
+            existingTask.completedAt = task.completedAt;
+            this.updateView();
+        }
+    }
+    failTask(task) {
+        const existingTask = this.tasks.get(task.id);
+        if (existingTask) {
+            existingTask.status = 'failed';
+            existingTask.error = task.error;
+            existingTask.completedAt = task.completedAt;
+            this.updateView();
+        }
+    }
+    removeTask(taskId) {
+        this.tasks.delete(taskId);
+        this.taskCallbacks.delete(taskId);
+        this.updateView();
+    }
+    addConsoleMessage(message) {
+        this.consoleMessages.push(message);
+        if (this.view) {
+            this.view.addConsoleMessage(message);
+        }
+    }
+    updateView() {
+        if (this.view) {
+            const rootTasks = Array.from(this.tasks.values()).filter(t => !t.parentId);
+            const activeTasks = Array.from(this.tasks.values()).filter(t => t.status === 'active');
+            const overallProgress = this.calculateOverallProgress(activeTasks);
+            this.view.updateTasks(rootTasks, overallProgress);
+            this.view.updateConsoleMessages(this.consoleMessages);
+        }
+    }
+    calculateOverallProgress(tasks) {
+        if (tasks.length === 0)
+            return 0; // No active tasks means 0% progress
+        let totalProgress = 0;
+        tasks.forEach(task => {
+            if (task.totalSteps > 0) {
+                totalProgress += (task.currentStep / task.totalSteps) * 100;
+            }
+            else {
+                totalProgress += task.progress;
+            }
+        });
+        return Math.round(totalProgress / tasks.length);
+    }
+    formatDuration(startedAt, completedAt) {
+        const duration = completedAt - startedAt;
+        const seconds = Math.floor(duration / 1000);
+        const minutes = Math.floor(seconds / 60);
+        if (minutes > 0) {
+            return `${minutes}m ${seconds % 60}s`;
+        }
+        return `${seconds}s`;
+    }
+    getActiveTasks() {
+        return Array.from(this.tasks.values()).filter(t => t.status === 'active');
+    }
+    getAllTasks() {
+        return Array.from(this.tasks.values());
+    }
+    getConsoleMessages() {
+        return this.consoleMessages;
+    }
+    registerTaskCallback(taskId, callback) {
+        if (!this.taskCallbacks.has(taskId)) {
+            this.taskCallbacks.set(taskId, []);
+        }
+        this.taskCallbacks.get(taskId).push(callback);
+    }
+    unregisterTaskCallback(taskId, callback) {
+        if (!callback) {
+            this.taskCallbacks.delete(taskId);
+        }
+        else {
+            const callbacks = this.taskCallbacks.get(taskId);
+            if (callbacks) {
+                const index = callbacks.indexOf(callback);
+                if (index > -1) {
+                    callbacks.splice(index, 1);
+                }
+                if (callbacks.length === 0) {
+                    this.taskCallbacks.delete(taskId);
+                }
+            }
+        }
+    }
+    triggerTaskCallbacks(taskId, task) {
+        const callbacks = this.taskCallbacks.get(taskId);
+        if (callbacks) {
+            callbacks.forEach(callback => {
+                try {
+                    callback(task);
+                }
+                catch (error) {
+                    console.error('Error in task callback:', error);
+                }
+            });
+            this.taskCallbacks.delete(taskId);
+        }
+    }
+    waitForTask(taskId) {
+        return new Promise((resolve) => {
+            const existingTask = this.tasks.get(taskId);
+            if (existingTask && (existingTask.status === 'completed' || existingTask.status === 'failed')) {
+                resolve(existingTask);
+                return;
+            }
+            this.registerTaskCallback(taskId, (task) => {
+                resolve(task);
+            });
+        });
+    }
+    subscribeToTaskType(taskType, callback, actions = [TaskAction.Complete, TaskAction.Fail]) {
+        const subscription = { taskType, actions, callback };
+        if (!this.typeSubscriptions.has(taskType)) {
+            this.typeSubscriptions.set(taskType, new Set());
+        }
+        this.typeSubscriptions.get(taskType).add(subscription);
+        return () => {
+            const subs = this.typeSubscriptions.get(taskType);
+            if (subs) {
+                subs.delete(subscription);
+                if (subs.size === 0) {
+                    this.typeSubscriptions.delete(taskType);
+                }
+            }
+        };
+    }
+    notifyTypeSubscribers(task, action) {
+        const subs = this.typeSubscriptions.get(task.type);
+        if (!subs)
+            return;
+        for (const sub of subs) {
+            if (sub.actions.includes(action)) {
+                try {
+                    sub.callback(task);
+                }
+                catch (error) {
+                    console.error(`Error in task type callback for ${task.type}:`, error);
+                }
+            }
+        }
+    }
+    destroy() {
+        // Clear all pending timeouts
+        this.pendingTimeouts.forEach(id => clearTimeout(id));
+        this.pendingTimeouts.clear();
+        // Unsubscribe from task stream
+        this.taskStreamSubscription?.unsubscribe();
+        this.taskStreamSubscription = null;
+        this.typeSubscriptions.clear();
+        this.taskCallbacks.clear();
+        this.tasks.clear();
+        this.consoleMessages = [];
+        if (this.mockGenerator) {
+            this.mockGenerator.stop();
+        }
+    }
+}

package/dist/controllers/model-controller.d.ts

@@ -1,8 +1,30 @@
-import { TheDoctor } from "../components/the-doctor/the-doctor.js";
-import { GraphResponse } from "../model/graph";
+import { Edge, GraphResponse, Node, VacuumResult } from "../model/graph.js";
+import { RenderedNodeComponent } from "../components/model-renderer/rendered-node.js";
+import type { ModelControllerDeps } from "../interfaces/doctor-interfaces.js";
 export declare class ModelController extends EventTarget {
-    doc: TheDoctor;
-    constructor(doc: TheDoctor);
+    private readonly deps;
+    nodes: Node[];
+    edges: Edge[];
+    nodeMap: Map<string, Node>;
+    nodePathIndex: Map<string, Node>;
+    violationMap: Map<string, VacuumResult>;
+    filteredNodeMap: Map<string, Node>;
+    activeNode: Node;
+    renderedNodeComponent: RenderedNodeComponent;
+    changeNodeMap: Map<string, Node>;
+    changeNodePathIndex: Map<string, Node>;
+    changeViolationMap: Map<string, VacuumResult>;
+    changeReport: GraphResponse | null;
+    private _originalNodeMap;
+    private _originalNodePathIndex;
+    constructor(deps: ModelControllerDeps);
+    private populateViolationMap;
+    private buildNodeIndices;
     fetchRefMap(currentPath?: string): void;
     extractGraph(graph: GraphResponse): void;
+    updateChangeReport(changeReport: GraphResponse): void;
+    captureOriginalGraph(): void;
+    get originalNodeMap(): Map<string, Node> | null;
+    get originalNodePathIndex(): Map<string, Node> | null;
+    clearOriginalGraph(): void;
 }

package/dist/controllers/model-controller.js

@@ -1,24 +1,52 @@
 import { GraphBag } from "../components/the-doctor/the-doctor.js";
-import { ModelService } from "../services/model-service";
-import { ToastType } from "../model/toast";
+import { ModelService } from "../services/model-service.js";
+import { ToastType } from "../model/toast.js";
 export class ModelController extends EventTarget {
-    constructor(doc) {
+    constructor(deps) {
         super();
-        this.doc = doc;
+        // original graph snapshot (pre-bundle)
+        this._originalNodeMap = null;
+        this._originalNodePathIndex = null;
+        this.deps = deps;
+        this.edges = [];
+        this.nodeMap = new Map();
+        this.nodePathIndex = new Map();
+        this.violationMap = new Map();
+        this.changeNodeMap = new Map();
+        this.changeNodePathIndex = new Map();
+        this.changeViolationMap = new Map();
+        this.filteredNodeMap = new Map();
+        this.changeReport = null;
+    }
+    populateViolationMap(violations, targetMap) {
+        if (!violations)
+            return;
+        for (const id in violations) {
+            if (Object.prototype.hasOwnProperty.call(violations, id)) {
+                targetMap.set(id, violations[id]);
+            }
+        }
+    }
+    buildNodeIndices(nodes, idMap, pathMap) {
+        for (const node of nodes) {
+            idMap.set(node.id, node);
+            if (node.nodePath) {
+                pathMap.set(node.nodePath, node);
+            }
+        }
     }
     fetchRefMap(currentPath = '') {
         ModelService.fetchReferenceMap(currentPath).then((result) => {
-            this.doc.editor.clearDecorations();
-            this.doc.references = result;
-            this.doc.editor.links = result;
-            this.doc.editor.applyLinkDecorations();
-            // add references to our stateful bag
-            this.doc.updateRefmapBag(currentPath, result);
+            this.deps.editor.clearDecorations();
+            this.deps.references = result;
+            this.deps.editor.links = result;
+            this.deps.editor.applyLinkDecorations();
+            this.deps.updateRefmapBag(currentPath, result);
         }).catch((e) => {
             console.error('an error occurred fetching the reference map', currentPath, e);
-            this.doc.editor.clearDecorations();
-            this.doc.editor.clearAllMarkers();
-            this.doc.toastManager.addToastManually({
+            this.deps.editor.clearDecorations();
+            this.deps.editor.clearAllMarkers();
+            this.deps.sendToast({
                 id: crypto.randomUUID(),
                 type: ToastType.INFO,
                 title: "File not analyzed",
@@ -27,61 +55,69 @@ export class ModelController extends EventTarget {
         });
     }
     extractGraph(graph) {
-        // handled stripped nodes
-        if (graph.stripped) {
-            this.doc.explorer.nodeLimitExceeded = true;
-            this.doc.modelTree.nodeLimitExceeded = true;
-            if (graph.strippedCount) {
-                this.doc.explorer.nodeLimit = graph.strippedCount;
-                this.doc.modelTree.nodeLimit = graph.strippedCount;
+        this.deps.explorer.nodeLimitExceeded = false;
+        // wipe it all out.
+        this.nodes = [];
+        this.edges = [];
+        this.filteredNodeMap.clear();
+        this.nodeMap.clear();
+        this.nodePathIndex.clear();
+        this.violationMap.clear();
+        this.populateViolationMap(graph.violations, this.violationMap);
+        this.nodes = graph.nodes;
+        this.edges = graph.edges;
+        this.buildNodeIndices(graph.nodes ?? [], this.nodeMap, this.nodePathIndex);
+        for (const node of graph.nodes ?? []) {
+            if (node.filtered) {
+                this.filteredNodeMap.set(node.id, node);
+            }
+            if (this.activeNode?.id === node.id && this.renderedNodeComponent) {
+                this.renderedNodeComponent.node = node;
             }
         }
-        else {
-            this.doc.explorer.nodeLimitExceeded = false;
-            this.doc.modelTree.nodeLimitExceeded = false;
+        this.deps.graphBag?.set(GraphBag, graph);
+        this.deps.explorer.updateGraphResponse(graph);
+        this.deps.modelTree.nodeMap = this.nodeMap;
+        this.deps.modelTree.violationMap = this.violationMap;
+        if (this.renderedNodeComponent) {
+            this.renderedNodeComponent.violationMap = this.violationMap;
         }
-        this.doc.explorer.renderedNodeMap.clear();
-        this.doc.nodeMap.clear();
-        this.doc.nodeIdMap.clear();
-        this.doc.nodeIdHashMap.clear();
-        const renderedNodes = new Map();
-        graph?.nodesRendered?.forEach((node) => {
-            this.doc.explorer.renderedNodeMap.set(node.id, node);
-            renderedNodes.set(node.id, node);
-        });
-        for (let i = 0; i < graph?.nodesRendered?.length; i++) {
-            this.doc.renderedNodeMap.set(graph.nodesRendered[i].id, graph.nodesRendered[i]);
+        if (this.nodeMap.has('root')) {
+            this.deps.modelTree.node = this.nodeMap.get('root');
         }
-        graph?.nodes?.forEach((node) => {
-            this.doc.nodeMap.set(node.id, node);
-            if (node.idHash.includes('root')) {
-                this.doc.nodeIdMap.set('root', node);
-                this.doc.nodeIdHashMap.set(node.id, node);
-            }
-            else {
-                this.doc.nodeIdMap.set(node.id, node);
-                this.doc.nodeIdHashMap.set(node.idHash, node);
-            }
-            if (node.filtered) {
-                this.doc.filteredNodes.set(node.id, node);
-            }
-            const renderedNode = this.doc.renderedNodeMap.get(node.id);
-            if (this.doc.activeNode?.id === node.id && this.doc.renderedNodeMap.get(node.id)) {
-                if (this.doc.renderedNode && renderedNode) {
-                    this.doc.renderedNode.node = renderedNode;
-                }
+    }
+    // a new change report was selected.
+    updateChangeReport(changeReport) {
+        this.changeReport = changeReport;
+        // iterate through all the nodes in the change report and build a specific map, just for that report
+        // so our change explorer can always find everything it's looking for.
+        if (this.changeReport) {
+            this.changeNodeMap.clear();
+            this.changeNodePathIndex.clear();
+            this.changeViolationMap.clear();
+            this.populateViolationMap(this.changeReport.violations, this.changeViolationMap);
+            this.buildNodeIndices(this.changeReport.nodes, this.changeNodeMap, this.changeNodePathIndex);
+            // update the time vortex model tree, it maintains its own state.
+            if (this.deps.timeVortex?.tardisControl?.modelTree) {
+                this.deps.timeVortex.tardisControl.modelTree.nodeMap = this.changeNodeMap;
+                this.deps.timeVortex.tardisControl.modelTree.violationMap = this.changeViolationMap;
             }
-        });
-        this.doc.graphBag?.set(GraphBag, graph);
-        this.doc.explorer.updateGraphResponse(graph);
-        if (graph && graph.nodes) {
-            this.doc.modelTree.node = graph?.nodesRendered[0]; // update tree
         }
-        if (!this.doc.explorer.equalizer.isInitialized()) {
-            this.doc.explorer.equalizer.initializeEqualizer();
-        }
-        else {
-            this.doc.explorer.equalizer.runEQ(true);
+    }
+    captureOriginalGraph() {
+        if (this.nodeMap && this.nodePathIndex) {
+            this._originalNodeMap = new Map(this.nodeMap);
+            this._originalNodePathIndex = new Map(this.nodePathIndex);
         }
     }
+    get originalNodeMap() {
+        return this._originalNodeMap;
+    }
+    get originalNodePathIndex() {
+        return this._originalNodePathIndex;
+    }
+    clearOriginalGraph() {
+        this._originalNodeMap = null;
+        this._originalNodePathIndex = null;
+    }
 }