@aeolun/dijkstra-calculator - npm Package Compare versions

Comparing version 1.3.2 to 1.4.0

build/main/lib/index.d.ts

@@ -5,35 +5,48 @@ /**
 export type NodeId = string;
-export interface Node {
+export interface Node<RESOURCES extends string> {
     id: NodeId;
-    properties: PathProperties;
+    properties: PathProperties<RESOURCES>;
 }
-export interface LinkedListItem {
+type PartialRecord<K extends keyof any, T> = Partial<Record<K, T>>;
+export interface LinkedListItem<RESOURCES extends string> {
     source: NodeId;
     target: NodeId;
     edge?: NodeId;
-    consumes?: Record<string, number>;
-    recover?: Record<string, number>;
+    consumes?: PartialRecord<RESOURCES, number>;
+    recover?: PartialRecord<RESOURCES, number>;
     weight?: number;
+    weightFromResources?: number;
+    totalConsumed?: PartialRecord<RESOURCES, number>;
+    totalRecovered?: PartialRecord<RESOURCES, number>;
 }
-export interface VertexProperties {
-    recover?: Record<string, boolean>;
+export interface VertexProperties<RESOURCES extends string> {
+    recover?: PartialRecord<RESOURCES, (currentLevel: number, maxLevel: number) => {
+        recoverAmount: number;
+        cost: number;
+    }>;
 }
-export interface EdgeProperties {
+export interface EdgeProperties<RESOURCES extends string> {
     id?: string;
     weight: number;
-    consumes?: Record<string, number>;
-    recover?: Record<string, number>;
+    consumes?: PartialRecord<RESOURCES, number>;
+    recover?: PartialRecord<RESOURCES, number>;
+    totalConsumed?: PartialRecord<RESOURCES, number>;
+    totalRecovered?: PartialRecord<RESOURCES, number>;
+    weightFromResources?: number;
 }
-export interface PathProperties {
+export interface PathProperties<RESOURCES extends string> {
     priority: number;
-    supplies?: Record<string, number>;
-    maxSupplies?: Record<string, number>;
+    supplies?: PartialRecord<RESOURCES, number>;
+    supplyCapacity?: PartialRecord<RESOURCES, number>;
+    totalConsumed?: PartialRecord<RESOURCES, number>;
+    totalRecovered?: PartialRecord<RESOURCES, number>;
+    resourceWeight?: PartialRecord<RESOURCES, number>;
 }
-export type PathReturnProperties = PathProperties & {
+export type PathReturnProperties<RESOURCES extends string> = PathProperties<RESOURCES> & {
     timeTaken: number;
 };
-export type PathNode = {
+export type PathNode<RESOURCES extends string> = {
     vertexId: NodeId;
-} & Partial<EdgeProperties>;
-export declare class DijkstraCalculator {
+} & Partial<EdgeProperties<RESOURCES>>;
+export declare class DijkstraCalculator<RESOURCES extends string> {
     private heuristic?;
@@ -44,12 +57,16 @@ private isDebugging;
             id: NodeId;
-            properties: EdgeProperties;
+            properties: EdgeProperties<RESOURCES>;
         }[];
     };
     vertexProperties: {
-        [key: NodeId]: VertexProperties;
+        [key: NodeId]: VertexProperties<RESOURCES>;
     };
     constructor(heuristic?: ((vertex: NodeId, target: NodeId) => number) | undefined, isDebugging?: boolean);
-    addVertex(vertex: NodeId, properties?: VertexProperties): void;
-    addEdge(vertex1: NodeId, vertex2: NodeId, properties?: EdgeProperties): void;
+    addVertex(vertex: NodeId, properties?: VertexProperties<RESOURCES>): void;
+    addEdge(vertex1: NodeId, vertex2: NodeId, properties?: EdgeProperties<RESOURCES>): void;
     debug(...args: any[]): void;
+    calculateShortestRouteAsLinkedListResults(nodes: NodeId[], properties?: Omit<PathProperties<RESOURCES>, 'priority'>): {
+        finalPath: LinkedListItem<RESOURCES>[];
+        pathProperties: PathReturnProperties<RESOURCES>;
+    };
     /**
@@ -61,5 +78,5 @@ * Given the provided weights of each edge
      */
-    calculateShortestPathAsLinkedListResult(start: NodeId, finish: NodeId, properties?: Omit<PathProperties, 'priority'>): {
-        finalPath: LinkedListItem[];
-        pathProperties: PathReturnProperties;
+    calculateShortestPathAsLinkedListResult(start: NodeId, finish: NodeId, properties?: Omit<PathProperties<RESOURCES>, 'priority'>): {
+        finalPath: LinkedListItem<RESOURCES>[];
+        pathProperties: PathReturnProperties<RESOURCES>;
     };
@@ -72,6 +89,7 @@ /**
      */
-    calculateShortestPath(start: NodeId, finish: NodeId, properties?: Omit<PathProperties, 'priority'>): {
+    calculateShortestPath(start: NodeId, finish: NodeId, properties?: Omit<PathProperties<RESOURCES>, 'priority'>): {
         finalPath: string[];
-        pathProperties: PathReturnProperties;
+        pathProperties: PathReturnProperties<RESOURCES>;
     };
 }
+export {};

build/main/lib/index.js

@@ -91,2 +91,62 @@ "use strict";
     }
+    calculateShortestRouteAsLinkedListResults(nodes, properties = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        // calculate route from first node hitting all specified nodes in order
+        const startNode = nodes.shift();
+        if (!startNode) {
+            throw new Error('No nodes provided');
+        }
+        const results = {
+            finalPath: [],
+            pathProperties: {
+                priority: 0,
+                timeTaken: 0,
+                supplies: {},
+                totalConsumed: {},
+                totalRecovered: {},
+                resourceWeight: {},
+            },
+        };
+        let currentNode = startNode;
+        while (nodes.length > 0) {
+            const nextNode = nodes.shift();
+            if (!nextNode) {
+                throw new Error('No nodes provided');
+            }
+            const route = this.calculateShortestPathAsLinkedListResult(currentNode, nextNode, Object.assign(Object.assign({}, properties), { supplies: Object.assign(Object.assign({}, properties.supplies), results.pathProperties.supplies) }));
+            results.finalPath = results.finalPath.concat(route.finalPath);
+            results.pathProperties.priority += route.pathProperties.priority;
+            results.pathProperties.timeTaken += route.pathProperties.timeTaken;
+            for (const supply in route.pathProperties.supplies) {
+                if (results.pathProperties.supplies) {
+                    results.pathProperties.supplies[supply] =
+                        ((_a = results.pathProperties.supplies[supply]) !== null && _a !== void 0 ? _a : 0) +
+                            ((_c = (_b = route.pathProperties.supplies) === null || _b === void 0 ? void 0 : _b[supply]) !== null && _c !== void 0 ? _c : 0);
+                }
+            }
+            for (const supply in route.pathProperties.totalConsumed) {
+                if (results.pathProperties.totalConsumed) {
+                    results.pathProperties.totalConsumed[supply] =
+                        ((_d = results.pathProperties.totalConsumed[supply]) !== null && _d !== void 0 ? _d : 0) +
+                            ((_f = (_e = route.pathProperties.totalConsumed) === null || _e === void 0 ? void 0 : _e[supply]) !== null && _f !== void 0 ? _f : 0);
+                }
+            }
+            for (const supply in route.pathProperties.totalRecovered) {
+                if (results.pathProperties.totalRecovered) {
+                    results.pathProperties.totalRecovered[supply] =
+                        ((_g = results.pathProperties.totalRecovered[supply]) !== null && _g !== void 0 ? _g : 0) +
+                            ((_j = (_h = route.pathProperties.totalRecovered) === null || _h === void 0 ? void 0 : _h[supply]) !== null && _j !== void 0 ? _j : 0);
+                }
+            }
+            for (const supply in route.pathProperties.resourceWeight) {
+                if (results.pathProperties.resourceWeight) {
+                    results.pathProperties.resourceWeight[supply] =
+                        ((_k = results.pathProperties.resourceWeight[supply]) !== null && _k !== void 0 ? _k : 0) +
+                            ((_m = (_l = route.pathProperties.resourceWeight) === null || _l === void 0 ? void 0 : _l[supply]) !== null && _m !== void 0 ? _m : 0);
+                }
+            }
+            currentNode = nextNode;
+        }
+        return results;
+    }
     /**
@@ -99,3 +159,3 @@ * Given the provided weights of each edge
     calculateShortestPathAsLinkedListResult(start, finish, properties = {}) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         this.debug("Start running Dijkstra's algorithm");
@@ -146,16 +206,22 @@ const startTime = Date.now();
                     const newSupplies = Object.assign({}, distances[smallest].supplies);
-                    let recoverHere = {};
+                    const totalConsumed = Object.assign({}, distances[smallest].totalConsumed);
+                    const totalRecovered = Object.assign({}, distances[smallest].totalRecovered);
+                    const totalResourceWeight = Object.assign({}, distances[smallest].resourceWeight);
+                    let weightFromResources = 0;
+                    const recoverHere = {};
                     if (nextNode.properties.consumes) {
                         for (const supply in nextNode.properties.consumes) {
-                            if (newSupplies[supply]) {
-                                newSupplies[supply] -= nextNode.properties.consumes[supply];
-                            }
-                            else {
-                                newSupplies[supply] = -nextNode.properties.consumes[supply];
-                            }
-                            if (newSupplies[supply] < 0) {
-                                candidate += 1000000000;
-                            }
+                            const consumed = (_a = nextNode.properties.consumes[supply]) !== null && _a !== void 0 ? _a : 0;
+                            const originalSupply = (_b = newSupplies[supply]) !== null && _b !== void 0 ? _b : 0;
+                            newSupplies[supply] = originalSupply - consumed;
+                            totalConsumed[supply] = ((_c = totalConsumed[supply]) !== null && _c !== void 0 ? _c : 0) + consumed;
                         }
                     }
+                    // any step with negative supplies is a step we can't take
+                    for (const supply in newSupplies) {
+                        const supp = newSupplies[supply];
+                        if (supp && supp < 0) {
+                            candidate += Math.abs(supp) * 100000;
+                        }
+                    }
                     if (nextVertexProperties && nextVertexProperties.recover) {
@@ -165,10 +231,22 @@ this.debug('recover found');
                             const smallestSupplies = distances[smallest].supplies;
-                            if (properties.maxSupplies &&
-                                properties.maxSupplies[supply] &&
-                                smallestSupplies &&
-                                smallestSupplies[supply]) {
-                                const recoverAmount = properties.maxSupplies[supply] - newSupplies[supply];
+                            const supplyFunction = nextVertexProperties.recover[supply];
+                            const supplyCapacity = (_d = properties.supplyCapacity) === null || _d === void 0 ? void 0 : _d[supply];
+                            const currentSupply = (_e = newSupplies[supply]) !== null && _e !== void 0 ? _e : 0;
+                            if (!supplyCapacity) {
+                                throw new Error('No capacity for supply ' + supply + ', cannot recover.');
+                            }
+                            if (smallestSupplies &&
+                                smallestSupplies[supply] &&
+                                supplyFunction) {
+                                const { recoverAmount, cost } = supplyFunction(currentSupply, supplyCapacity);
+                                // increase cost of path by the amount of resources we need to recover times the cost of recovering here
+                                candidate += cost;
+                                weightFromResources += cost;
                                 recoverHere[supply] = recoverAmount;
+                                totalResourceWeight[supply] =
+                                    ((_f = totalResourceWeight[supply]) !== null && _f !== void 0 ? _f : 0) + cost;
+                                totalRecovered[supply] =
+                                    ((_g = totalRecovered[supply]) !== null && _g !== void 0 ? _g : 0) + recoverAmount;
                             }
-                            newSupplies[supply] = (_b = (_a = properties.maxSupplies) === null || _a === void 0 ? void 0 : _a[supply]) !== null && _b !== void 0 ? _b : 0;
+                            newSupplies[supply] = (_j = (_h = properties.supplyCapacity) === null || _h === void 0 ? void 0 : _h[supply]) !== null && _j !== void 0 ? _j : 0;
                         }
@@ -179,4 +257,7 @@ }
                         priority: candidate,
+                        totalConsumed,
+                        totalRecovered,
+                        resourceWeight: totalResourceWeight,
                     };
-                    this.debug('On ', smallest, ' traveling to ', nextNode.id, ' state at end of trip ', newProperties);
+                    this.debug('On ', smallest, ' over ', nextNode.properties.id, ' traveling to ', nextNode.id, ' state at end of trip ', newProperties);
                     const nextNeighbor = nextNode.id;
@@ -189,3 +270,3 @@ if (candidate < distances[nextNeighbor].priority) {
                         previous[nextNeighbor] = smallest;
-                        previousEdgeId[nextNeighbor] = Object.assign(Object.assign({}, nextNode.properties), { recover: recoverHere });
+                        previousEdgeId[nextNeighbor] = Object.assign(Object.assign({}, nextNode.properties), { recover: recoverHere, weightFromResources });
                         //enqueue in priority queue with new priority
@@ -229,2 +310,5 @@ nodes.enqueue(nextNeighbor, newProperties);
                     weight: finalPath[i + 1].weight,
+                    weightFromResources: finalPath[i + 1].weightFromResources,
+                    totalConsumed: finalPath[i + 1].totalConsumed,
+                    totalRecovered: finalPath[i + 1].totalRecovered,
                 }
@@ -249,3 +333,3 @@ : {
         const result = this.calculateShortestPathAsLinkedListResult(start, finish, properties);
-        let finalPath = [];
+        const finalPath = [];
         if (result.finalPath.length > 0) {
@@ -265,2 +349,2 @@ result.finalPath.forEach((item, index) => {
 exports.DijkstraCalculator = DijkstraCalculator;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/index.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/index.ts"],"names":[],"mappings":"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"}

build/module/lib/index.d.ts

@@ -5,35 +5,48 @@ /**
 export type NodeId = string;
-export interface Node {
+export interface Node<RESOURCES extends string> {
     id: NodeId;
-    properties: PathProperties;
+    properties: PathProperties<RESOURCES>;
 }
-export interface LinkedListItem {
+type PartialRecord<K extends keyof any, T> = Partial<Record<K, T>>;
+export interface LinkedListItem<RESOURCES extends string> {
     source: NodeId;
     target: NodeId;
     edge?: NodeId;
-    consumes?: Record<string, number>;
-    recover?: Record<string, number>;
+    consumes?: PartialRecord<RESOURCES, number>;
+    recover?: PartialRecord<RESOURCES, number>;
     weight?: number;
+    weightFromResources?: number;
+    totalConsumed?: PartialRecord<RESOURCES, number>;
+    totalRecovered?: PartialRecord<RESOURCES, number>;
 }
-export interface VertexProperties {
-    recover?: Record<string, boolean>;
+export interface VertexProperties<RESOURCES extends string> {
+    recover?: PartialRecord<RESOURCES, (currentLevel: number, maxLevel: number) => {
+        recoverAmount: number;
+        cost: number;
+    }>;
 }
-export interface EdgeProperties {
+export interface EdgeProperties<RESOURCES extends string> {
     id?: string;
     weight: number;
-    consumes?: Record<string, number>;
-    recover?: Record<string, number>;
+    consumes?: PartialRecord<RESOURCES, number>;
+    recover?: PartialRecord<RESOURCES, number>;
+    totalConsumed?: PartialRecord<RESOURCES, number>;
+    totalRecovered?: PartialRecord<RESOURCES, number>;
+    weightFromResources?: number;
 }
-export interface PathProperties {
+export interface PathProperties<RESOURCES extends string> {
     priority: number;
-    supplies?: Record<string, number>;
-    maxSupplies?: Record<string, number>;
+    supplies?: PartialRecord<RESOURCES, number>;
+    supplyCapacity?: PartialRecord<RESOURCES, number>;
+    totalConsumed?: PartialRecord<RESOURCES, number>;
+    totalRecovered?: PartialRecord<RESOURCES, number>;
+    resourceWeight?: PartialRecord<RESOURCES, number>;
 }
-export type PathReturnProperties = PathProperties & {
+export type PathReturnProperties<RESOURCES extends string> = PathProperties<RESOURCES> & {
     timeTaken: number;
 };
-export type PathNode = {
+export type PathNode<RESOURCES extends string> = {
     vertexId: NodeId;
-} & Partial<EdgeProperties>;
-export declare class DijkstraCalculator {
+} & Partial<EdgeProperties<RESOURCES>>;
+export declare class DijkstraCalculator<RESOURCES extends string> {
     private heuristic?;
@@ -44,12 +57,16 @@ private isDebugging;
             id: NodeId;
-            properties: EdgeProperties;
+            properties: EdgeProperties<RESOURCES>;
         }[];
     };
     vertexProperties: {
-        [key: NodeId]: VertexProperties;
+        [key: NodeId]: VertexProperties<RESOURCES>;
     };
     constructor(heuristic?: ((vertex: NodeId, target: NodeId) => number) | undefined, isDebugging?: boolean);
-    addVertex(vertex: NodeId, properties?: VertexProperties): void;
-    addEdge(vertex1: NodeId, vertex2: NodeId, properties?: EdgeProperties): void;
+    addVertex(vertex: NodeId, properties?: VertexProperties<RESOURCES>): void;
+    addEdge(vertex1: NodeId, vertex2: NodeId, properties?: EdgeProperties<RESOURCES>): void;
     debug(...args: any[]): void;
+    calculateShortestRouteAsLinkedListResults(nodes: NodeId[], properties?: Omit<PathProperties<RESOURCES>, 'priority'>): {
+        finalPath: LinkedListItem<RESOURCES>[];
+        pathProperties: PathReturnProperties<RESOURCES>;
+    };
     /**
@@ -61,5 +78,5 @@ * Given the provided weights of each edge
      */
-    calculateShortestPathAsLinkedListResult(start: NodeId, finish: NodeId, properties?: Omit<PathProperties, 'priority'>): {
-        finalPath: LinkedListItem[];
-        pathProperties: PathReturnProperties;
+    calculateShortestPathAsLinkedListResult(start: NodeId, finish: NodeId, properties?: Omit<PathProperties<RESOURCES>, 'priority'>): {
+        finalPath: LinkedListItem<RESOURCES>[];
+        pathProperties: PathReturnProperties<RESOURCES>;
     };
@@ -72,6 +89,7 @@ /**
      */
-    calculateShortestPath(start: NodeId, finish: NodeId, properties?: Omit<PathProperties, 'priority'>): {
+    calculateShortestPath(start: NodeId, finish: NodeId, properties?: Omit<PathProperties<RESOURCES>, 'priority'>): {
         finalPath: string[];
-        pathProperties: PathReturnProperties;
+        pathProperties: PathReturnProperties<RESOURCES>;
     };
 }
+export {};

build/module/lib/index.js

@@ -93,2 +93,67 @@ class PriorityQueue {
     }
+    calculateShortestRouteAsLinkedListResults(nodes, properties = {}) {
+        // calculate route from first node hitting all specified nodes in order
+        const startNode = nodes.shift();
+        if (!startNode) {
+            throw new Error('No nodes provided');
+        }
+        const results = {
+            finalPath: [],
+            pathProperties: {
+                priority: 0,
+                timeTaken: 0,
+                supplies: {},
+                totalConsumed: {},
+                totalRecovered: {},
+                resourceWeight: {},
+            },
+        };
+        let currentNode = startNode;
+        while (nodes.length > 0) {
+            const nextNode = nodes.shift();
+            if (!nextNode) {
+                throw new Error('No nodes provided');
+            }
+            const route = this.calculateShortestPathAsLinkedListResult(currentNode, nextNode, {
+                ...properties,
+                supplies: {
+                    ...properties.supplies,
+                    ...results.pathProperties.supplies,
+                },
+            });
+            results.finalPath = results.finalPath.concat(route.finalPath);
+            results.pathProperties.priority += route.pathProperties.priority;
+            results.pathProperties.timeTaken += route.pathProperties.timeTaken;
+            for (const supply in route.pathProperties.supplies) {
+                if (results.pathProperties.supplies) {
+                    results.pathProperties.supplies[supply] =
+                        (results.pathProperties.supplies[supply] ?? 0) +
+                            (route.pathProperties.supplies?.[supply] ?? 0);
+                }
+            }
+            for (const supply in route.pathProperties.totalConsumed) {
+                if (results.pathProperties.totalConsumed) {
+                    results.pathProperties.totalConsumed[supply] =
+                        (results.pathProperties.totalConsumed[supply] ?? 0) +
+                            (route.pathProperties.totalConsumed?.[supply] ?? 0);
+                }
+            }
+            for (const supply in route.pathProperties.totalRecovered) {
+                if (results.pathProperties.totalRecovered) {
+                    results.pathProperties.totalRecovered[supply] =
+                        (results.pathProperties.totalRecovered[supply] ?? 0) +
+                            (route.pathProperties.totalRecovered?.[supply] ?? 0);
+                }
+            }
+            for (const supply in route.pathProperties.resourceWeight) {
+                if (results.pathProperties.resourceWeight) {
+                    results.pathProperties.resourceWeight[supply] =
+                        (results.pathProperties.resourceWeight[supply] ?? 0) +
+                            (route.pathProperties.resourceWeight?.[supply] ?? 0);
+                }
+            }
+            currentNode = nextNode;
+        }
+        return results;
+    }
     /**
@@ -146,17 +211,31 @@ * Given the provided weights of each edge
                         (this.heuristic ? this.heuristic(nextNode.id, finish) : 0);
-                    const newSupplies = { ...distances[smallest].supplies };
-                    let recoverHere = {};
+                    const newSupplies = {
+                        ...distances[smallest].supplies,
+                    };
+                    const totalConsumed = {
+                        ...distances[smallest].totalConsumed,
+                    };
+                    const totalRecovered = {
+                        ...distances[smallest].totalRecovered,
+                    };
+                    const totalResourceWeight = {
+                        ...distances[smallest].resourceWeight,
+                    };
+                    let weightFromResources = 0;
+                    const recoverHere = {};
                     if (nextNode.properties.consumes) {
                         for (const supply in nextNode.properties.consumes) {
-                            if (newSupplies[supply]) {
-                                newSupplies[supply] -= nextNode.properties.consumes[supply];
-                            }
-                            else {
-                                newSupplies[supply] = -nextNode.properties.consumes[supply];
-                            }
-                            if (newSupplies[supply] < 0) {
-                                candidate += 1000000000;
-                            }
+                            const consumed = nextNode.properties.consumes[supply] ?? 0;
+                            const originalSupply = newSupplies[supply] ?? 0;
+                            newSupplies[supply] = originalSupply - consumed;
+                            totalConsumed[supply] = (totalConsumed[supply] ?? 0) + consumed;
                         }
                     }
+                    // any step with negative supplies is a step we can't take
+                    for (const supply in newSupplies) {
+                        const supp = newSupplies[supply];
+                        if (supp && supp < 0) {
+                            candidate += Math.abs(supp) * 100000;
+                        }
+                    }
                     if (nextVertexProperties && nextVertexProperties.recover) {
@@ -166,10 +245,22 @@ this.debug('recover found');
                             const smallestSupplies = distances[smallest].supplies;
-                            if (properties.maxSupplies &&
-                                properties.maxSupplies[supply] &&
-                                smallestSupplies &&
-                                smallestSupplies[supply]) {
-                                const recoverAmount = properties.maxSupplies[supply] - newSupplies[supply];
+                            const supplyFunction = nextVertexProperties.recover[supply];
+                            const supplyCapacity = properties.supplyCapacity?.[supply];
+                            const currentSupply = newSupplies[supply] ?? 0;
+                            if (!supplyCapacity) {
+                                throw new Error('No capacity for supply ' + supply + ', cannot recover.');
+                            }
+                            if (smallestSupplies &&
+                                smallestSupplies[supply] &&
+                                supplyFunction) {
+                                const { recoverAmount, cost } = supplyFunction(currentSupply, supplyCapacity);
+                                // increase cost of path by the amount of resources we need to recover times the cost of recovering here
+                                candidate += cost;
+                                weightFromResources += cost;
                                 recoverHere[supply] = recoverAmount;
+                                totalResourceWeight[supply] =
+                                    (totalResourceWeight[supply] ?? 0) + cost;
+                                totalRecovered[supply] =
+                                    (totalRecovered[supply] ?? 0) + recoverAmount;
                             }
-                            newSupplies[supply] = properties.maxSupplies?.[supply] ?? 0;
+                            newSupplies[supply] = properties.supplyCapacity?.[supply] ?? 0;
                         }
@@ -180,4 +271,7 @@ }
                         priority: candidate,
+                        totalConsumed,
+                        totalRecovered,
+                        resourceWeight: totalResourceWeight,
                     };
-                    this.debug('On ', smallest, ' traveling to ', nextNode.id, ' state at end of trip ', newProperties);
+                    this.debug('On ', smallest, ' over ', nextNode.properties.id, ' traveling to ', nextNode.id, ' state at end of trip ', newProperties);
                     const nextNeighbor = nextNode.id;
@@ -193,2 +287,3 @@ if (candidate < distances[nextNeighbor].priority) {
                             recover: recoverHere,
+                            weightFromResources,
                         };
@@ -233,2 +328,5 @@ //enqueue in priority queue with new priority
                     weight: finalPath[i + 1].weight,
+                    weightFromResources: finalPath[i + 1].weightFromResources,
+                    totalConsumed: finalPath[i + 1].totalConsumed,
+                    totalRecovered: finalPath[i + 1].totalRecovered,
                 }
@@ -256,3 +354,3 @@ : {
         const result = this.calculateShortestPathAsLinkedListResult(start, finish, properties);
-        let finalPath = [];
+        const finalPath = [];
         if (result.finalPath.length > 0) {
@@ -271,2 +369,2 @@ result.finalPath.forEach((item, index) => {
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/index.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/index.ts"],"names":[],"mappings":"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"}

package.json

 {
   "name": "@aeolun/dijkstra-calculator",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "Dijkstra calculator for the shortest path in a graph of nodes given a weight.",
@@ -15,8 +15,7 @@ "main": "build/main/index.js",
   "devDependencies": {
-    "@types/node": "^18.15.3",
     "@ava/typescript": "^1.1.1",
     "@istanbuljs/nyc-config-typescript": "^1.0.1",
+    "@types/node": "^18.15.3",
     "@typescript-eslint/eslint-plugin": "^4.0.1",
     "@typescript-eslint/parser": "^4.0.1",
-    "ava": "5.3.1",
     "codecov": "^3.5.0",
@@ -37,4 +36,6 @@ "cspell": "^4.1.0",
     "ts-node": "^9.0.0",
+    "tsx": "^3.14.0",
     "typedoc": "^0.24.8",
-    "typescript": "^4.5.5"
+    "typescript": "^4.5.5",
+    "vitest": "^0.34.6"
   },
@@ -50,14 +51,2 @@ "files": [
   ],
-  "ava": {
-    "failFast": true,
-    "timeout": "60s",
-    "typescript": {
-      "rewritePaths": {
-        "src/": "build/main/"
-      }
-    },
-    "files": [
-      "!build/module/**"
-    ]
-  },
   "config": {},
@@ -82,5 +71,3 @@ "prettier": {
     "test:lint": "eslint src --ext .ts",
-    "test:prettier": "prettier \"src/**/*.ts\" --list-different",
-    "test:spelling": "cspell \"{README.md,.github/*.md,src/**/*.ts}\"",
-    "test:unit": "nyc --silent ava",
+    "test:unit": "vitest",
     "check-cli": "./node_modules/.bin/npm-run-all -s test diff-integration-tests check-integration-tests",
@@ -87,0 +74,0 @@ "check-integration-tests": "./node_modules/.bin/npm-run-all -s check-integration-test:*",

README.md

@@ -5,3 +5,3 @@ ![Dijkstra's Calculator](./banner.jpg)
 
-> @aeolun: This is mildly modified from the original to return the final weight for a route
+> @aeolun: This is fairly seriously modified from the original to return the final weight for a route, and take into account a variety of limits like fuel
 
@@ -8,0 +8,0 @@ - **GitHub URL**: https://github.com/getditto/dijkstra-calculator

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

238599

increased by122.93%

Number of package files

26

increased by62.5%

Lines of code

3980

increased by167.47%

Worsened metrics

Dev dependency count

24

increased by4.35%

Number of low supply chain risk alerts

3

increased by200%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes