piemachine 0.0.2 → 0.0.4

package/dist/pieMachine.d.ts

@@ -1,24 +1,27 @@
 import { ConditionalFunc, Edge, PieMachineConfig } from "./types.js";
-export declare class GoToNode<T, N extends string> {
-    to: N;
+export declare class GoToNode<T> {
+    to: string;
     data: T;
-    constructor(to: N, data: T);
+    constructor(to: string, data: T);
 }
-export declare function goToNode<T, N extends string>(to: N, data: T): GoToNode<T, N>;
-export declare class PieMachine<T, N extends string> {
+export declare function goToNode<T>(to: string, data: T): GoToNode<T>;
+export declare class PieMachine<T> {
     private nodes;
     private edges;
     private config;
     private statelogClient;
-    constructor(nodes: readonly N[], config?: PieMachineConfig<T>);
-    node(id: N, func: (data: T) => Promise<T | GoToNode<T, N>>): void;
-    edge(from: N, to: N): void;
-    conditionalEdge<const Adjacent extends N>(from: N, adjacentNodes: readonly Adjacent[], to?: ConditionalFunc<T, Adjacent>): void;
+    private nodesTraversed;
+    constructor(nodes: readonly string[], config?: PieMachineConfig<T>);
+    node(id: string, func: (data: T) => Promise<T | GoToNode<T>>): void;
+    edge(from: string, to: string): void;
+    conditionalEdge<const Adjacent extends string>(from: string, adjacentNodes: readonly Adjacent[], to?: ConditionalFunc<T, Adjacent>): void;
     debug(message: string, data?: T): void;
-    run(startId: N, input: T): Promise<T>;
-    runAndValidate(nodeFunc: (data: T) => Promise<T | GoToNode<T, N>>, currentId: N, _data: T, retries?: number): Promise<T | GoToNode<T, N>>;
+    getNodesTraversed(): readonly string[];
+    run(startId: string, input: T): Promise<T>;
+    runAndValidate(nodeFunc: (data: T) => Promise<T | GoToNode<T>>, currentId: string, _data: T, retries?: number): Promise<T | GoToNode<T>>;
     prettyPrint(): void;
-    prettyPrintEdge(edge: Edge<T, N>): string;
+    prettyPrintEdge(edge: Edge<T, string>): string;
     toMermaid(): string;
+    merge(another: PieMachine<T>): void;
     private validateGoToNodeTarget;
 }

package/dist/pieMachine.js

@@ -26,6 +26,7 @@ export class PieMachine {
         this.nodes = {};
         this.edges = {};
         this.statelogClient = null;
+        this.nodesTraversed = [];
         this.config = config;
         if (config.statelog) {
             this.statelogClient = new StatelogClient({
@@ -67,9 +68,13 @@ export class PieMachine {
         }
         //this.statelogClient?.debug(message, data || {});
     }
+    getNodesTraversed() {
+        return this.nodesTraversed;
+    }
     run(startId, input) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            this.nodesTraversed = [];
             const jsonEdges = {};
             for (const from in this.edges) {
                 jsonEdges[from] = edgeToJSON(this.edges[from]);
@@ -82,6 +87,7 @@ export class PieMachine {
             let currentId = startId;
             let data = input;
             while (currentId) {
+                this.nodesTraversed.push(currentId);
                 const nodeFunc = this.nodes[currentId];
                 if (!nodeFunc) {
                     throw new PieMachineError(`Node function for ${currentId} not found.`);
@@ -174,7 +180,11 @@ export class PieMachine {
                         currentId = nextId;
                     }
                     else {
-                        throw new PieMachineError(`Expected ${currentId} to return a GoToNode, as no function was specified for the conditional edges to ${edge.adjacentNodes.join(", ")}.`);
+                        this.debug(`Exiting graph from node: ${color.green(currentId)}`);
+                        currentId = null;
+                        /* throw new PieMachineError(
+                          `Expected ${currentId} to return a GoToNode, as no function was specified for the conditional edges to ${edge.adjacentNodes.join(", ")}.`,
+                        ); */
                     }
                 }
             }
@@ -239,6 +249,22 @@ export class PieMachine {
         }
         return mermaid;
     }
+    merge(another) {
+        for (const nodeId in another.nodes) {
+            if (this.nodes[nodeId]) {
+                throw new PieMachineError(`Node ${nodeId} already exists in the current PieMachine.`);
+            }
+            this.nodes[nodeId] =
+                another.nodes[nodeId];
+        }
+        for (const from in another.edges) {
+            if (this.edges[from]) {
+                throw new PieMachineError(`Edge from ${from} already exists in the current PieMachine.`);
+            }
+            this.edges[from] =
+                another.edges[from];
+        }
+    }
     validateGoToNodeTarget(to, edge) {
         if (!isRegularEdge(edge)) {
             if (edge.adjacentNodes.includes(to)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "piemachine",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "A general-purpose library for defining and running state machines. Easy as pie.",
   "homepage": "https://github.com/egonSchiele/piemachine",
   "scripts": {