@workglow/util 0.0.52

package/dist/events/EventEmitter.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A type that represents a listener function for an event.
+ * @template Events - A record of event names and their corresponding listener functions
+ * @template EventType - The name of the event
+ */
+type EventListener<Events, EventType extends keyof Events> = Events[EventType];
+/**
+ * A type that represents the parameters of an event.
+ * @template Events - A record of event names and their corresponding listener functions
+ * @template EventType - The name of the event
+ */
+export type EventParameters<Events, EventType extends keyof Events> = {
+    [Event in EventType]: EventListener<Events, EventType> extends (...args: infer P) => any ? P : never;
+}[EventType];
+/**
+ * A type that represents the return type of the emitted method.
+ * @template Events - A record of event names and their corresponding listener functions
+ * @template EventType - The name of the event
+ */
+export type EmittedReturnType<Events, EventType extends keyof Events> = EventParameters<Events, EventType>;
+/**
+ * A class that implements an event emitter pattern.
+ * @template EventListenerTypes - A record of event names and their corresponding listener functions
+ */
+export declare class EventEmitter<EventListenerTypes extends Record<string, (...args: any) => any>> {
+    private listeners;
+    /**
+     * Remove all listeners for a specific event or all events
+     * @param event - Optional event name. If not provided, removes all listeners for all events
+     * @returns this, so that calls can be chained
+     */
+    removeAllListeners<Event extends keyof EventListenerTypes>(event?: Event): this;
+    /**
+     * Adds a listener function for the event
+     * @param event - The event name to listen for
+     * @param listener - The listener function to add
+     * @returns this, so that calls can be chained
+     */
+    on<Event extends keyof EventListenerTypes>(event: Event, listener: EventListener<EventListenerTypes, Event>): this;
+    /**
+     * Removes a listener function for the event
+     * @param event - The event name to remove the listener from
+     * @param listener - The listener function to remove
+     * @returns this, so that calls can be chained
+     */
+    off<Event extends keyof EventListenerTypes>(event: Event, listener: EventListener<EventListenerTypes, Event>): this;
+    /**
+     * Adds a listener function for the event that will be called only once
+     * @param event - The event name to listen for
+     * @param listener - The listener function to add
+     * @returns this, so that calls can be chained
+     */
+    once<Event extends keyof EventListenerTypes>(event: Event, listener: EventListener<EventListenerTypes, Event>): this;
+    /**
+     * Returns a promise that resolves when the event is emitted
+     * @param event - The event name to listen for
+     * @returns a promise that resolves to an array of all parameters of the event (empty array for events with no parameters)
+     */
+    waitOn<Event extends keyof EventListenerTypes>(event: Event): Promise<EmittedReturnType<EventListenerTypes, Event>>;
+    /**
+     * Emits an event with the specified name and arguments
+     * @param event - The event name to emit
+     * @param args - Arguments to pass to the event listeners
+     */
+    emit<Event extends keyof EventListenerTypes>(this: EventEmitter<EventListenerTypes>, event: Event, ...args: EventParameters<EventListenerTypes, Event>): void;
+    /**
+     * Subscribes to an event and returns a function to unsubscribe
+     * @param event - The event name to subscribe to
+     * @param listener - The listener function to add
+     * @returns a function to unsubscribe from the event
+     */
+    subscribe<Event extends keyof EventListenerTypes>(event: Event, listener: EventListener<EventListenerTypes, Event>): () => void;
+}
+export {};
+//# sourceMappingURL=EventEmitter.d.ts.map

package/dist/events/EventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitter.d.ts","sourceRoot":"","sources":["../../src/events/EventEmitter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AACH,KAAK,aAAa,CAAC,MAAM,EAAE,SAAS,SAAS,MAAM,MAAM,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC;AAY/E;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,MAAM,EAAE,SAAS,SAAS,MAAM,MAAM,IAAI;KACnE,KAAK,IAAI,SAAS,GAAG,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,GAAG,GACpF,CAAC,GACD,KAAK;CACV,CAAC,SAAS,CAAC,CAAC;AAEb;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,MAAM,EAAE,SAAS,SAAS,MAAM,MAAM,IAAI,eAAe,CACrF,MAAM,EACN,SAAS,CACV,CAAC;AAEF;;;GAGG;AACH,qBAAa,YAAY,CAAC,kBAAkB,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC;IACxF,OAAO,CAAC,SAAS,CAEV;IAEP;;;;OAIG;IACH,kBAAkB,CAAC,KAAK,SAAS,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI;IAS/E;;;;;OAKG;IACH,EAAE,CAAC,KAAK,SAAS,MAAM,kBAAkB,EACvC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,aAAa,CAAC,kBAAkB,EAAE,KAAK,CAAC,GACjD,IAAI;IAOP;;;;;OAKG;IACH,GAAG,CAAC,KAAK,SAAS,MAAM,kBAAkB,EACxC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,aAAa,CAAC,kBAAkB,EAAE,KAAK,CAAC,GACjD,IAAI;IAWP;;;;;OAKG;IACH,IAAI,CAAC,KAAK,SAAS,MAAM,kBAAkB,EACzC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,aAAa,CAAC,kBAAkB,EAAE,KAAK,CAAC,GACjD,IAAI;IAOP;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAS,MAAM,kBAAkB,EAC3C,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;IAYxD;;;;OAIG;IACI,IAAI,CAAC,KAAK,SAAS,MAAM,kBAAkB,EAChD,IAAI,EAAE,YAAY,CAAC,kBAAkB,CAAC,EACtC,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,eAAe,CAAC,kBAAkB,EAAE,KAAK,CAAC;IAYrD;;;;;OAKG;IACI,SAAS,CAAC,KAAK,SAAS,MAAM,kBAAkB,EACrD,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,aAAa,CAAC,kBAAkB,EAAE,KAAK,CAAC,GACjD,MAAM,IAAI;CAId"}

package/dist/graph/directedAcyclicGraph.d.ts

@@ -0,0 +1,70 @@
+import { DirectedGraph } from "./directedGraph";
+/**
+ * # DirectedAcyclicGraph
+ *
+ * A DirectedAcyclicGraph is builds on a [[`DirectedGraph`]] but enforces acyclicality. You cannot add an edge to a DirectedAcyclicGraph that would create a cycle.
+ *
+ * @typeParam Node `Node` is the node type of the graph. Nodes can be anything in all the included examples they are simple objects.
+ * @typeParam Edge `Edge` is the edge type of the graph. Edges can be of any type, but must be truethy and by default they are `true` which is a simple boolean.
+ * @typeParam NodeId `NodeId` is the identity type of the node, by default it is a `unknown`, though most will use `string` or `number`.
+ * @typeParam EdgeId `EdgeId` is the identity type of the edge, by default it is a `unknown`, though most will use `string` or `number`.
+ */
+export declare class DirectedAcyclicGraph<Node, Edge = true, NodeId = unknown, EdgeId = unknown> extends DirectedGraph<Node, Edge, NodeId, EdgeId> {
+    private _topologicallySortedNodes?;
+    /**
+     * Converts an existing directed graph into a directed acyclic graph.
+     * Throws a {@linkcode CycleError} if the graph attempting to be converted contains a cycle.
+     * @param graph The source directed graph to convert into a DAG
+     */
+    static fromDirectedGraph<Node, Edge, NodeId, EdgeId>(graph: DirectedGraph<Node, Edge, NodeId, EdgeId>): DirectedAcyclicGraph<Node, Edge, NodeId, EdgeId>;
+    /**
+     * Adds an edge to the graph similarly to [[`DirectedGraph.addEdge`]] but maintains correctness of the acyclic graph.
+     * Thows a [[`CycleError`]] if adding the requested edge would create a cycle.
+     * Adding an edge invalidates the cache of topologically sorted nodes, rather than updating it.
+     *
+     * @param sourceNodeIdentity The identity string of the node the edge should run from.
+     * @param targetNodeIdentity The identity string of the node the edge should run to.
+     * @param edge The edge to add to the graph. If not provided it defaults to `true`.
+     */
+    addEdge(sourceNodeIdentity: NodeId, targetNodeIdentity: NodeId, edge?: Edge): EdgeId;
+    /**
+     * Inserts a node into the graph and maintains topologic sort cache by prepending the node
+     * (since all newly created nodes have an [[ indegreeOfNode | indegree ]] of zero.)
+     *
+     * @param node The node to insert
+     */
+    insert(node: Node): NodeId;
+    /**
+     * Topologically sort the nodes using Kahn's algorithm. Uses a cache which means that repeated calls should be O(1) after the first call.
+     * Non-cached calls are potentially expensive, Kahn's algorithim is O(|EdgeCount| + |NodeCount|).
+     * There may be more than one valid topological sort order for a single graph,
+     * so just because two graphs are the same does not mean that order of the resultant arrays will be.
+     *
+     * @returns An array of nodes sorted by the topological order.
+     */
+    topologicallySortedNodes(): Node[];
+    /**
+     * Given a starting node this returns a new [[`DirectedA`]] containing all the nodes that can be reached.
+     * Throws a [[`NodeDoesntExistError`]] if the start node does not exist.
+     *
+     * @param startNodeIdentity The string identity of the node from which the subgraph search should start.
+     */
+    getSubGraphStartingFrom(startNodeIdentity: NodeId): DirectedAcyclicGraph<Node, Edge, NodeId, EdgeId>;
+    /**
+     * Deletes an edge between two nodes in the graph.
+     * Throws a [[`NodeDoesNotExistsError`]] if either of the nodes do not exist.
+     *
+     * @param sourceNodeIdentity The identity of the source node
+     * @param targetNodeIdentity The identity of the target node
+     * @param edgeIdentity The identity of the edge to be deleted. If not provided, all edges between the two nodes will be deleted.
+     */
+    removeEdge(sourceNodeIdentity: NodeId, targetNodeIdentity: NodeId, edgeIdentity?: EdgeId): void;
+    /**
+     * Deletes a node from the graph, along with any edges associated with it.
+     * Throws a [[`NodeDoesNotExistsError`]] if the node does not exist.
+     *
+     * @param nodeIdentity The identity of the node to be deleted.
+     */
+    remove(nodeIdentity: NodeId): void;
+}
+//# sourceMappingURL=directedAcyclicGraph.d.ts.map

package/dist/graph/directedAcyclicGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directedAcyclicGraph.d.ts","sourceRoot":"","sources":["../../src/graph/directedAcyclicGraph.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD;;;;;;;;;GASG;AACH,qBAAa,oBAAoB,CAC/B,IAAI,EACJ,IAAI,GAAG,IAAI,EACX,MAAM,GAAG,OAAO,EAChB,MAAM,GAAG,OAAO,CAChB,SAAQ,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC;IACjD,OAAO,CAAC,yBAAyB,CAAC,CAAS;IAE3C;;;;OAIG;IACH,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EACjD,KAAK,EAAE,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,GAC/C,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC;IAiBnD;;;;;;;;OAQG;IACH,OAAO,CAAC,kBAAkB,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM;IAiBpF;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAQ1B;;;;;;;OAOG;IACH,wBAAwB,IAAI,IAAI,EAAE;IA0DlC;;;;;OAKG;IACH,uBAAuB,CACrB,iBAAiB,EAAE,MAAM,GACxB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC;IAInD;;;;;;;OAOG;IACH,UAAU,CAAC,kBAAkB,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI;IAO/F;;;;;OAKG;IACH,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;CAMnC"}

package/dist/graph/directedGraph.d.ts

@@ -0,0 +1,90 @@
+import { Graph } from "./graph";
+/**
+ * # DirectedGraph
+ *
+ * A DirectedGraph is similar a [[`Graph`]] but with additional functionality.
+ *
+ * @typeParam Node `Node` is the node type of the graph. Nodes can be anything in all the included examples they are simple objects.
+ * @typeParam Edge `Edge` is the edge type of the graph. Edges can be of any type, but must be truethy and by default they are `true` which is a simple boolean.
+ * @typeParam NodeId `NodeId` is the identity type of the node, by default it is a `unknown`, though most will use `string` or `number`.
+ * @typeParam EdgeId `EdgeId` is the identity type of the edge, by default it is a `unknown`, though most will use `string` or `number`.
+ */
+export declare class DirectedGraph<Node, Edge = true, NodeId = unknown, EdgeId = unknown> extends Graph<Node, Edge, NodeId, EdgeId> {
+    /** Caches if the graph contains a cycle. If `undefined` then it is unknown. */
+    protected hasCycle: boolean | undefined;
+    /**
+     * Returns `true` if there are no cycles in the graph.
+     * This relies on a cached value so calling it multiple times without adding edges to the graph should be O(1) after the first call.
+     * Non-cached calls are potentially expensive, the implementation is based on Kahn's algorithim which is O(|EdgeCount| + |NodeCount|).
+     */
+    isAcyclic(): boolean;
+    /**
+     * The indegree of a node is the number of edges that point to it. This will always be an integer.
+     *
+     * Throws a [[`NodeDoesntExistError`]] the node does not exist.
+     *
+     * @param nodeID The string of the node identity of the node to calculate indegree for.
+     */
+    indegreeOfNode(nodeID: NodeId): number;
+    /**
+     * Add a directed edge to the graph.
+     *
+     * @param sourceNodeIdentity The identity string of the node the edge should run from.
+     * @param targetNodeIdentity The identity string of the node the edge should run to.
+     * @param edge The edge to add to the graph. If not provided it defaults to `true`.
+     * @param skipUpdatingCyclicality This boolean indicates if the cache of the cyclicality of the graph should be updated.
+     * If `false` is passed the cycle cache will be invalidated because we can not assure that a cycle has not been created.
+     */
+    addEdge(sourceNodeIdentity: NodeId, targetNodeIdentity: NodeId, edge?: Edge, skipUpdatingCyclicality?: boolean): EdgeId;
+    /**
+     * Depth first search to see if one node is reachable from another following the directed edges.
+     *
+     * __Caveat:__ This will return false if `startNode` and `endNode` are the same node and there is not a cycle or a loop edge connecting them.
+     *
+     * @param startNode The string identity of the node to start at.
+     * @param endNode The string identity of the node we are attempting to reach.
+     */
+    canReachFrom(startNode: NodeId, endNode: NodeId): boolean;
+    /**
+     * Checks if adding the specified edge would create a cycle.
+     * Returns true in O(1) if the graph already contains a known cycle, or if `sourceNodeIdentity` and `targetNodeIdentity` are the same.
+     *
+     * @param sourceNodeIdentity The string identity of the node the edge is from.
+     * @param targetNodeIdentity The string identity of the node the edge is to.
+     */
+    wouldAddingEdgeCreateCycle(sourceNodeIdentity: NodeId, targetNodeIdentity: NodeId): boolean;
+    /**
+     * Given a starting node this returns a new [[`DirectedGraph`]] containing all the nodes that can be reached.
+     * Throws a [[`NodeDoesntExistError`]] if the start node does not exist.
+     *
+     * @param startNodeIdentity The string identity of the node from which the subgraph search should start.
+     */
+    getSubGraphStartingFrom(startNodeIdentity: NodeId): DirectedGraph<Node, Edge, NodeId, EdgeId>;
+    private subAdj;
+    /**
+     * Returns all edges in the graph as an array of tuples.
+     */
+    getEdges(): Array<[sourceNodeIdentity: NodeId, targetNodeIdentity: NodeId, edge: Edge]>;
+    /**
+     * Deletes an edge between two nodes in the graph.
+     * Throws a [[`NodeDoesNotExistsError`]] if either of the nodes do not exist.
+     *
+     * @param sourceNodeIdentity The identity of the source node
+     * @param targetNodeIdentity The identity of the target node
+     * @param edgeIdentity The identity of the edge to be deleted. If not provided, all edges between the two nodes will be deleted.
+     */
+    removeEdge(sourceNodeIdentity: NodeId, targetNodeIdentity: NodeId, edgeIdentity?: EdgeId): void;
+    /**
+     * Deletes a node from the graph, along with any edges associated with it.
+     * Throws a [[`NodeDoesNotExistsError`]] if the node does not exist.
+     *
+     * @param nodeIdentity The identity of the node to be deleted.
+     */
+    remove(nodeIdentity: NodeId): void;
+    /**
+     * Add edges
+     * @param edges An array of tuples, each tuple containing the identity of the source node, the identity of the target node, and the edge to add.
+     */
+    addEdges(edges: Array<[sourceNodeIdentity: NodeId, targetNodeIdentity: NodeId, edge?: Edge | undefined]>): EdgeId[];
+}
+//# sourceMappingURL=directedGraph.d.ts.map

package/dist/graph/directedGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directedGraph.d.ts","sourceRoot":"","sources":["../../src/graph/directedGraph.ts"],"names":[],"mappings":"AAKA,OAAO,EAAwB,KAAK,EAAE,MAAM,SAAS,CAAC;AAEtD;;;;;;;;;GASG;AACH,qBAAa,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,CAAE,SAAQ,KAAK,CAC7F,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,MAAM,CACP;IACC,+EAA+E;IAC/E,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAS;IAEhD;;;;OAIG;IACH,SAAS,IAAI,OAAO;IAyCpB;;;;;;OAMG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAatC;;;;;;;;OAQG;IACH,OAAO,CACL,kBAAkB,EAAE,MAAM,EAC1B,kBAAkB,EAAE,MAAM,EAC1B,IAAI,CAAC,EAAE,IAAI,EACX,uBAAuB,GAAE,OAAe,GACvC,MAAM;IAaT;;;;;;;OAOG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;IAkBzD;;;;;;OAMG;IACH,0BAA0B,CAAC,kBAAkB,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,GAAG,OAAO;IAQ3F;;;;;OAKG;IACH,uBAAuB,CAAC,iBAAiB,EAAE,MAAM,GAAG,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC;IA0C7F,OAAO,CAAC,MAAM;IAad;;OAEG;IACH,QAAQ,IAAI,KAAK,CAAC,CAAC,kBAAkB,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IAIvF;;;;;;;OAOG;IACH,UAAU,CAAC,kBAAkB,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI;IAO/F;;;;;OAKG;IACH,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAOlC;;;OAGG;IACH,QAAQ,CACN,KAAK,EAAE,KAAK,CAAC,CAAC,kBAAkB,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC,CAAC,GAC9F,MAAM,EAAE;CAGZ"}

package/dist/graph/errors.d.ts

@@ -0,0 +1,38 @@
+import { BaseError } from "../utilities/BaseError";
+/**
+ * # NodeAlreadyExistsError
+ *
+ * This error is thrown when trying to create a node with the same identity as an existing node.
+ *
+ * @category Errors
+ */
+export declare class NodeAlreadyExistsError<T> extends BaseError {
+    static type: string;
+    newNode: T;
+    oldNode: T;
+    identity: unknown;
+    constructor(newNode: T, oldNode: T, identity: unknown);
+}
+/**
+ * # NodeDoesntExistError
+ * This error is thrown when trying to access a node in a graph by it's identity when that node doesn't exist
+ *
+ * @category Errors
+ */
+export declare class NodeDoesntExistError extends BaseError {
+    static type: string;
+    identity: unknown;
+    constructor(identity: unknown);
+}
+/**
+ * # CycleError
+ *
+ * This error is thrown when attempting to create or update a Directed Acyclic Graph that contains a cycle.
+ *
+ * @category Errors
+ */
+export declare class CycleError extends BaseError {
+    static type: string;
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/graph/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/graph/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD;;;;;;GAMG;AACH,qBAAa,sBAAsB,CAAC,CAAC,CAAE,SAAQ,SAAS;IACtD,OAAc,IAAI,EAAE,MAAM,CAA4B;IAC/C,OAAO,EAAE,CAAC,CAAC;IACX,OAAO,EAAE,CAAC,CAAC;IACX,QAAQ,EAAE,OAAO,CAAC;gBAEb,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,OAAO;CActD;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IACjD,OAAc,IAAI,EAAE,MAAM,CAA0B;IAC7C,QAAQ,EAAE,OAAO,CAAC;gBAEb,QAAQ,EAAE,OAAO;CAQ9B;AAED;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,SAAS;IACvC,OAAc,IAAI,EAAE,MAAM,CAAgB;gBAC9B,OAAO,EAAE,MAAM;CAO5B"}

package/dist/graph/graph.d.ts

@@ -0,0 +1,217 @@
+import { EventEmitter } from "../events/EventEmitter";
+/**
+ * This is the default [[Graph.constructor | `nodeIdentity`]] function it is simply imported from [object-hash](https://www.npmjs.com/package/object-hash)
+ */
+/**
+ * # Graph
+ *
+ * A `Graph` is is a simple undirected graph. On it's own it isn't too useful but it forms the basic functionality for the [[`DirectedGraph`]] and [[`DirectedAcyclicGraph`]].
+ *
+ * ## Creating a Graph
+ *
+ * You can create a graph to contain any type of node, for example:
+ *
+ * ```typescript
+ * type NodeType = { a: Number, b: string }
+ * const graph = new Graph<NodeType>()
+ *
+ * // Add a node of the defined type
+ * const node: string = graph.insert({ a: 10, b: 'string' })
+ *
+ * // Get the node back
+ * const nodeValue: NodeType | undefined = graph.getNode(node);
+ * ```
+ *
+ * ### Defining a custom node identity
+ *
+ * When you create a graph you likely want to create include a custom `nodeIdentity` function.
+ * This function tells the graph how to uniquely identify nodes in a graph,
+ * default is to simply use an [[hash]] which means that functionality like [[`replace`]] will not work.
+ *
+ * ```typescript
+ * type NodeType = { count: number, name: string }
+ * const graph = new Graph<NodeType>((n) => n.name)
+ *
+ * // Add a node
+ * graph.insert({ count: 5, name: 'node1' })
+ * // This will throw an error even though `count` is different because they share a name.
+ * graph.insert({ count: 20, name: 'node1' })
+ * ```
+ *
+ * ### Adding an edge
+ *
+ * Graphs without edges aren't very useful. Inserting edges is done using the node identity string returned by the node identity function.
+ *
+ * ```typescript
+ * const node1: string = graph.insert({ count: 5, name: 'node1' })
+ * const node2: string = graph.insert({ count: 20, name: 'node2' })
+ *
+ * graph.addEdge(node1, node2)
+ *
+ * // This will throw an error since there is no node with the later name.
+ * graph.addEdge(node1, 'not a real node')
+ * ```
+ *
+ * In an undirected graph the order in which you input the node names doesn't matter,
+ * but in directed graphs the "from node" comes first and the "to node" will come second.
+ *
+ * ### Replacing a node
+ *
+ * If a node already exists you can update it using [[`replace`]]. `nodeIdentity(newNode)` must be equal to `nodeIdentity(oldNode)`.
+ *
+ * ```typescript
+ * const node1: string = graph.insert({ count: 5, name: 'node1' })
+ * const node2: string = graph.insert({ count: 20, name: 'node2' })
+ *
+ * // This will work because the name has not changed.
+ * graph.replace({ count: 15, name: 'node1' })
+ *
+ * // This will not work because the name has changed.
+ * graph.replace({ count: 20, name: 'node3' })
+ * ```
+ *
+ * [[`replace`]] will throw a [[`NodeDoesntExistError`]] exception if you are trying to replace a node that is missing from the graph.
+ *
+ * ### Upsert
+ *
+ * Often you will want to create a node node if it doesn't exist and update it does. This can be achieved using [[`upsert`]].
+ *
+ * ```typescript
+ * const node1: string = graph.insert({ count: 5, name: 'node1' })
+ *
+ * // Both of these will work, the first updating node1 and the second creating a node.
+ * const node2: string = graph.upsert({ count: 15, name: 'node1' })
+ * const node3: string = graph.upsert({ count: 25, name: 'node3' })
+ * ```
+ *
+ * [[`upsert`]] always return the node identity string of the inserted or updated node. At presented there is no way to tell if the node was created or updated.
+ *
+ * @typeParam Node `Node` is the node type of the graph. Nodes can be anything in all the included examples they are simple objects.
+ * @typeParam Edge `Edge` is the edge type of the graph. Edges can be of any type, but must be truethy and by default they are `true` which is a simple boolean.
+ * @typeParam NodeId `NodeId` is the identity type of the node, by default it is a `unknown`, though most will use `string` or `number`.
+ * @typeParam EdgeId `EdgeId` is the identity type of the edge, by default it is a `unknown`, though most will use `string` or `number`.
+ */
+export type AdjacencyValue<Edge> = null | Array<Edge>;
+export type AdjacencyMatrix<Edge> = Array<Array<AdjacencyValue<Edge>>>;
+/**
+ * Events that can be emitted by the TaskGraph
+ */
+export type GraphEvents<Node, Edge> = keyof GraphEventListeners<Node, Edge>;
+export type GraphEventListeners<Node, Edge> = {
+    "node-added": (node: Node) => void;
+    "node-removed": (node: Node) => void;
+    "node-replaced": (node: Node) => void;
+    "edge-added": (edge: Edge) => void;
+    "edge-removed": (edge: Edge) => void;
+    "edge-replaced": (edge: Edge) => void;
+};
+export type GraphEventListener<Node, Edge, Event extends GraphEvents<Node, Edge>> = GraphEventListeners<Node, Edge>[Event];
+export type GraphEventParameters<Node, Edge, Event extends GraphEvents<Node, Edge>> = Parameters<GraphEventListeners<Node, Edge>[Event]>;
+export declare class Graph<Node, Edge = true, NodeId = unknown, EdgeId = unknown> {
+    protected nodes: Map<NodeId, Node>;
+    protected adjacency: AdjacencyMatrix<Edge>;
+    protected nodeIdentity: (t: Node) => NodeId;
+    protected edgeIdentity: (t: Edge, n1: NodeId, n2: NodeId) => EdgeId;
+    constructor(nodeIdentity: (node: Node) => NodeId, edgeIdentity: (edge: Edge, node1Identity: NodeId, node2Identit: NodeId) => EdgeId);
+    events: EventEmitter<GraphEventListeners<Node, Edge>>;
+    on(name: GraphEvents<Node, Edge>, fn: (...args: any[]) => void): void;
+    off(name: GraphEvents<Node, Edge>, fn: (...args: any[]) => void): void;
+    emit(name: GraphEvents<Node, Edge>, ...args: any[]): void;
+    /**
+     * Add a node to the graph if it doesn't already exist. If it does, throw a [[`NodeAlreadyExistsError`]].
+     *
+     * @param node The node to be added
+     * @returns A `string` that is the identity of the newly inserted node. This is created by applying the [[constructor | `nodeIdentity`]].
+     */
+    insert(node: Node): NodeId;
+    /**
+     * This replaces an existing node in the graph with an updated version.
+     * Throws a [[`NodeDoesNotExistsError`]] if no node with the same identity already exists.
+     *
+     * __Caveat_:_ The default identity function means that this will never work since if the node changes it will have a different [[`hash`]].
+     *
+     * @param node The new node that is replacing the old one.
+     */
+    replace(node: Node): void;
+    /**
+     * This essentially combines the behavior of [[`insert`]] and [[`replace`]].
+     * If the node doesn't exist, create it. If the node already exists, replace it with the updated version.
+     *
+     * @param node The node to insert or update
+     * @returns The identity string of the node inserted or updated.
+     */
+    upsert(node: Node): NodeId;
+    /**
+     * Create an edge between two nodes in the graph.
+     * Throws a [[`NodeDoesNotExistsError`]] if no either of the nodes you are attempting to connect do not exist.
+     *
+     * @param node1Identity The first node to connect (in [[`DirectedGraph`]]s and [[`DirectedAcyclicGraph`]]s this is the `source` node.)
+     * @param node2Identity The second node to connect (in [[`DirectedGraph`]]s and [[`DirectedAcyclicGraph`]]s this is the `target` node)
+     * @param edge The edge to be added. By default this is `true` but it can be any type.
+     */
+    addEdge(node1Identity: NodeId, node2Identity: NodeId, edge?: Edge): EdgeId;
+    /**
+     * This simply returns all the nodes stored in the graph
+     *
+     * @param compareFunc An optional function that indicates the sort order of the returned array
+     */
+    getNodes(compareFunc?: (a: Node, b: Node) => number): Node[];
+    /**
+     * Returns a specific node given the node identity returned from the [[`insert`]] function
+     */
+    getNode(nodeIdentity: NodeId): Node | undefined;
+    /**
+     * Returns true if the node exists in the graph.
+     */
+    hasNode(nodeIdentity: NodeId): boolean;
+    /**
+     * Returns all edges in the graph as an array of tuples.
+     */
+    getEdges(): Array<[node1Identity: NodeId, node2Identity: NodeId, edge: Edge]>;
+    /**
+     * Returns the out edges for a specific node.
+     */
+    outEdges(node1Identity: NodeId): Array<[node1Identity: NodeId, node2Identity: NodeId, edge: Edge]>;
+    /**
+     * Returns the in edges for a specific node.
+     */
+    inEdges(node2Identity: NodeId): Array<[node1Identity: NodeId, node2Identity: NodeId, edge: Edge]>;
+    /**
+     * Returns the edges for a specific node.
+     */
+    nodeEdges(nodeIdentity: NodeId): Array<[node1Identity: NodeId, node2Identity: NodeId, edge: Edge]>;
+    /**
+     * Deletes an edge between two nodes in the graph.
+     * Throws a [[`NodeDoesNotExistsError`]] if either of the nodes do not exist.
+     *
+     * @param node1Identity The identity of the first node (in [[`DirectedGraph`]]s and [[`DirectedAcyclicGraph`]]s this is the `from` node.)
+     * @param node2Identity The identity of the second node (in [[`DirectedGraph`]]s and [[`DirectedAcyclicGraph`]]s this is the `to` node)
+     * @param edgeIdentity The identity of the edge to be deleted. If not provided, all edges between the two nodes will be deleted.
+     */
+    removeEdge(node1Identity: NodeId, node2Identity: NodeId, edgeIdentity?: EdgeId): void;
+    /**
+     * Deletes a node from the graph, along with any edges associated with it.
+     * Throws a [[`NodeDoesNotExistsError`]] if the node does not exist.
+     *
+     * @param nodeIdentity The identity of the node to be deleted.
+     */
+    remove(nodeIdentity: NodeId): void;
+    /**
+     * @alias remove
+     */
+    removeNode(nodeIdentity: NodeId): void;
+    /**
+     * @alias insert
+     */
+    addNode(node: Node): NodeId;
+    /**
+     * Add nodes in bulk
+     */
+    addNodes(nodes: Node[]): NodeId[];
+    /**
+     * Add edges
+     * @param edges An array of tuples, each tuple containing the identity of the source node, the identity of the target node, and the edge to add.
+     */
+    addEdges(edges: Array<[node1Identity: NodeId, node2Identity: NodeId, edge?: Edge | undefined]>): EdgeId[];
+}
+//# sourceMappingURL=graph.d.ts.map

package/dist/graph/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/graph/graph.ts"],"names":[],"mappings":"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"}

package/dist/graph/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./directedAcyclicGraph";
+export * from "./directedGraph";
+export * from "./graph";
+export * from "./errors";
+//# sourceMappingURL=index.d.ts.map

package/dist/graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graph/index.ts"],"names":[],"mappings":"AAIA,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC"}

package/dist/json-schema/DataPortSchema.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { JSONSchemaExtension } from "json-schema-to-ts";
+import { JsonSchema, JsonSchemaCustomProps } from "./JsonSchema";
+export type DataPortSchemaNonBoolean<EXTENSION extends JSONSchemaExtension = JsonSchemaCustomProps> = Exclude<JsonSchema<EXTENSION>, Boolean>;
+/**
+ * Narrows to object schemas while preserving all schema properties.
+ */
+export type DataPortSchemaObject<EXTENSION extends JSONSchemaExtension = JsonSchemaCustomProps> = DataPortSchemaNonBoolean<EXTENSION> & {
+    readonly type: "object";
+    readonly properties: Record<string, DataPortSchemaNonBoolean<EXTENSION>>;
+};
+export type DataPortSchema<EXTENSION extends JSONSchemaExtension = JsonSchemaCustomProps> = boolean | DataPortSchemaObject<EXTENSION>;
+//# sourceMappingURL=DataPortSchema.d.ts.map

package/dist/json-schema/DataPortSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataPortSchema.d.ts","sourceRoot":"","sources":["../../src/json-schema/DataPortSchema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAEjE,MAAM,MAAM,wBAAwB,CAClC,SAAS,SAAS,mBAAmB,GAAG,qBAAqB,IAC3D,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,oBAAoB,CAAC,SAAS,SAAS,mBAAmB,GAAG,qBAAqB,IAC5F,wBAAwB,CAAC,SAAS,CAAC,GAAG;IACpC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC;CAC1E,CAAC;AAEJ,MAAM,MAAM,cAAc,CAAC,SAAS,SAAS,mBAAmB,GAAG,qBAAqB,IACpF,OAAO,GACP,oBAAoB,CAAC,SAAS,CAAC,CAAC"}

package/dist/json-schema/FromSchema.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FromExtendedSchema, FromExtendedSchemaOptions, FromSchemaOptions } from "json-schema-to-ts";
+import type { JsonSchema, JsonSchemaCustomProps } from "./JsonSchema";
+export { FromSchemaOptions };
+/**
+ * Removes the [$JSONSchema] symbol property from a type
+ * This is needed because json-schema-to-ts adds this property which cannot be serialized
+ */
+export type StripJSONSchema<T> = T extends object ? {
+    [K in keyof T as K extends symbol ? never : K]: T[K];
+} : T;
+export declare const FromSchemaDefaultOptions: {
+    readonly parseNotKeyword: true;
+    readonly parseIfThenElseKeywords: false;
+    readonly keepDefaultedPropertiesOptional: true;
+    readonly references: false;
+    readonly deserialize: false;
+};
+export type FromSchema<SCHEMA extends JsonSchema<EXTENSION>, OPTIONS extends FromExtendedSchemaOptions<EXTENSION> = typeof FromSchemaDefaultOptions, EXTENSION extends JsonSchemaCustomProps = JsonSchemaCustomProps> = StripJSONSchema<FromExtendedSchema<EXTENSION, SCHEMA, OPTIONS>>;
+/**
+ * IncludeProps - Returns a new schema with only the specified properties
+ *
+ * This is a schema transformer that returns a new schema object.
+ * Use with FromSchema like: FromSchema<IncludeProps<typeof schema, typeof ["prop1", "prop2"]>>
+ *
+ * @template Schema - The JSON schema object (with 'as const')
+ * @template Keys - Readonly array type of property keys to include (use typeof ["key1", "key2"] as const)
+ *
+ * @example
+ * const schema = {
+ *   type: "object",
+ *   properties: {
+ *     name: { type: "string" },
+ *     age: { type: "number" },
+ *     email: { type: "string" }
+ *   },
+ *   required: ["name"],
+ *   additionalProperties: false
+ * } as const;
+ *
+ * type Filtered = FromSchema<IncludeProps<typeof schema, typeof ["name", "age"]>>;
+ * // => { name: string, age?: number }
+ */
+export type IncludeProps<Schema extends {
+    readonly type: "object";
+    readonly properties: Record<string, unknown>;
+}, Keys extends readonly (keyof Schema["properties"])[]> = Omit<Schema, "properties" | "required"> & {
+    readonly properties: {
+        readonly [K in Extract<keyof Schema["properties"], Keys[number]>]: Schema["properties"][K];
+    };
+} & (Schema extends {
+    readonly required: readonly (infer R extends string)[];
+} ? {
+    readonly required: readonly Extract<R, Keys[number]>[];
+} : {});
+/**
+ * ExcludeProps - Returns a new schema without the specified properties
+ *
+ * This is a schema transformer that returns a new schema object.
+ * Use with FromSchema like: FromSchema<ExcludeProps<typeof schema, typeof ["prop1", "prop2"]>>
+ *
+ * @template Schema - The JSON schema object (with 'as const')
+ * @template Keys - Readonly array type of property keys to exclude (use typeof ["key1", "key2"] as const)
+ *
+ * @example
+ * const schema = {
+ *   type: "object",
+ *   properties: {
+ *     name: { type: "string" },
+ *     age: { type: "number" },
+ *     email: { type: "string" }
+ *   },
+ *   required: ["name"],
+ *   additionalProperties: false
+ * } as const;
+ *
+ * type Filtered = FromSchema<ExcludeProps<typeof schema, typeof ["email"]>>;
+ * // => { name: string, age?: number }
+ */
+export type ExcludeProps<Schema extends {
+    readonly type: "object";
+    readonly properties: Record<string, unknown>;
+}, Keys extends readonly (keyof Schema["properties"])[]> = Omit<Schema, "properties" | "required"> & {
+    readonly properties: {
+        readonly [K in Exclude<keyof Schema["properties"], Keys[number]>]: Schema["properties"][K];
+    };
+} & (Schema extends {
+    readonly required: readonly (infer R extends string)[];
+} ? {
+    readonly required: readonly Exclude<R, Keys[number]>[];
+} : {});
+//# sourceMappingURL=FromSchema.d.ts.map